codebee 0.1.66 → 0.1.68

package/app/core/errorlog.py

@@ -1,137 +1,137 @@
-# -*- coding: utf-8 -*-
-"""错误台账：把分散在各处的失败（步骤失败/超时/看门狗击杀、CLI 启动失败）
-统一落成结构化记录——「客户遇到了问题我们根本不知道」的第一块拼图。
-
-落盘：data/errors/errors-YYYYMM.jsonl（按月分文件，append-only，一行一记录）。
-与 usage.py 同一套纪律：
-- record() 任何异常都吞掉——埋点失败绝不能影响任务执行；
-- 落盘前先脱敏（scrub_text）：密钥/令牌/绝对路径/超长文本一概不进台账。
-
-隐私红线（上传侧在 telemetry.py 再兜一道底）：
-1. API KEY / 凭据绝不入台账；
-2. 任务正文 / 章节内容（用户版权内容）绝不入台账——detail 只允许失败原因摘录；
-3. 绝对路径剥成相对片段。
-"""
-from __future__ import annotations
-
-import json
-import threading
-import time
-import uuid
-
-from . import paths
-from .redact import scrub_text
-
-LOCK = threading.RLock()
-
-FIELDS = ("id", "ts", "day", "category", "reason", "detail", "provider",
-          "model", "tool", "role", "run_id", "task_id", "step",
-          "exit_code", "app_version", "os")
-
-# detail 摘录上限（字符）：失败原因足够，不要变成日志搬运
-DETAIL_LIMIT = 600
-
-
-# ---------------------------------------------------------------- 脱敏
-
-def _coerce_str(v, limit):
-    return str(v or "")[:limit]
-
-
-def _os_tag():
-    import sys
-    return {"win32": "windows", "darwin": "macos"}.get(sys.platform, sys.platform)
-
-
-def _version():
-    try:
-        from . import selfupdate
-        return str(selfupdate.package_version() or "dev")
-    except Exception:
-        return "dev"
-
-
-def record(category="", reason="", detail="", provider="", model="", tool="",
-           role="", run_id="", task_id="", step=0, exit_code=None, source=""):
-    """追加一条错误记录。缺省字段留空；任何异常都吞掉（埋点不拖垮业务）。
-
-    category: step / run / launch / service（枚举放宽，未知值原样入库）
-    reason:   失败原因码（error_codes.ErrorCode 的字符串值优先，如 TIMEOUT）
-    detail:   失败摘录（内部先过 scrub_text，绝不存原文）
-    """
-    try:
-        rec = {
-            "id": "%s-%s" % (time.strftime("%Y-%m-%d %H:%M:%S"),
-                             uuid.uuid4().hex[:8]),
-            "ts": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "day": time.strftime("%Y-%m-%d"),
-            "category": _coerce_str(category, 24) or "step",
-            "reason": _coerce_str(reason, 40) or "UNKNOWN",
-            "detail": scrub_text(detail),
-            "provider": _coerce_str(provider, 60),
-            "model": _coerce_str(model, 80),
-            "tool": _coerce_str(tool, 24),
-            "role": _coerce_str(role, 40),
-            "run_id": _coerce_str(run_id, 64),
-            "task_id": _coerce_str(task_id, 64),
-            "step": int(step or 0),
-            "exit_code": exit_code,
-            "app_version": _version()[:24],
-            "os": _os_tag(),
-        }
-        line = json.dumps(rec, ensure_ascii=False)
-        day = rec["day"]
-        with LOCK:
-            paths.ERRORS_DIR.mkdir(parents=True, exist_ok=True)
-            with open(paths.ERRORS_DIR / ("errors-%s.jsonl" % day[:7].replace("-", "")),
-                      "a", encoding="utf-8") as f:
-                f.write(line + "\n")
-    except Exception:
-        pass
-
-
-def iter_records(days=0):
-    """按时间范围读取台账（days=0 表示全部）。返回按写入顺序的记录列表。"""
-    out = []
-    try:
-        files = sorted(paths.ERRORS_DIR.glob("errors-*.jsonl")) if paths.ERRORS_DIR.is_dir() else []
-    except Exception:
-        return out
-    since_day = ""
-    if days:
-        import datetime
-        since_day = (datetime.date.today()
-                     - datetime.timedelta(days=int(days) - 1)).isoformat()
-    for p in files:
-        try:
-            for line in p.read_text(encoding="utf-8", errors="replace").splitlines():
-                line = line.strip()
-                if not line.startswith("{"):
-                    continue
-                try:
-                    r = json.loads(line)
-                except Exception:
-                    continue
-                if not isinstance(r, dict):
-                    continue
-                if since_day and str(r.get("day", "")) < since_day:
-                    continue
-                out.append(r)
-        except Exception:
-            continue
-    return out
-
-
-def pending_since(cursor, limit=200):
-    """取 cursor（上次上传到的记录 id）之后的记录，最多 limit 条。
-
-    id 以时间开头、uuid 尾巴保证唯一且字典序≈时间序；返回 (records, new_cursor)。
-    """
-    try:
-        recs = [r for r in iter_records(0) if str(r.get("id") or "") > str(cursor or "")]
-        recs.sort(key=lambda r: str(r.get("id") or ""))
-        batch = recs[:max(1, int(limit))]
-        new_cursor = str(batch[-1].get("id")) if batch else str(cursor or "")
-        return batch, new_cursor
-    except Exception:
-        return [], str(cursor or "")
+# -*- coding: utf-8 -*-
+"""错误台账：把分散在各处的失败（步骤失败/超时/看门狗击杀、CLI 启动失败）
+统一落成结构化记录——「客户遇到了问题我们根本不知道」的第一块拼图。
+
+落盘：data/errors/errors-YYYYMM.jsonl（按月分文件，append-only，一行一记录）。
+与 usage.py 同一套纪律：
+- record() 任何异常都吞掉——埋点失败绝不能影响任务执行；
+- 落盘前先脱敏（scrub_text）：密钥/令牌/绝对路径/超长文本一概不进台账。
+
+隐私红线（上传侧在 telemetry.py 再兜一道底）：
+1. API KEY / 凭据绝不入台账；
+2. 任务正文 / 章节内容（用户版权内容）绝不入台账——detail 只允许失败原因摘录；
+3. 绝对路径剥成相对片段。
+"""
+from __future__ import annotations
+
+import json
+import threading
+import time
+import uuid
+
+from . import paths
+from .redact import scrub_text
+
+LOCK = threading.RLock()
+
+FIELDS = ("id", "ts", "day", "category", "reason", "detail", "provider",
+          "model", "tool", "role", "run_id", "task_id", "step",
+          "exit_code", "app_version", "os")
+
+# detail 摘录上限（字符）：失败原因足够，不要变成日志搬运
+DETAIL_LIMIT = 600
+
+
+# ---------------------------------------------------------------- 脱敏
+
+def _coerce_str(v, limit):
+    return str(v or "")[:limit]
+
+
+def _os_tag():
+    import sys
+    return {"win32": "windows", "darwin": "macos"}.get(sys.platform, sys.platform)
+
+
+def _version():
+    try:
+        from . import selfupdate
+        return str(selfupdate.package_version() or "dev")
+    except Exception:
+        return "dev"
+
+
+def record(category="", reason="", detail="", provider="", model="", tool="",
+           role="", run_id="", task_id="", step=0, exit_code=None, source=""):
+    """追加一条错误记录。缺省字段留空；任何异常都吞掉（埋点不拖垮业务）。
+
+    category: step / run / launch / service（枚举放宽，未知值原样入库）
+    reason:   失败原因码（error_codes.ErrorCode 的字符串值优先，如 TIMEOUT）
+    detail:   失败摘录（内部先过 scrub_text，绝不存原文）
+    """
+    try:
+        rec = {
+            "id": "%s-%s" % (time.strftime("%Y-%m-%d %H:%M:%S"),
+                             uuid.uuid4().hex[:8]),
+            "ts": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "day": time.strftime("%Y-%m-%d"),
+            "category": _coerce_str(category, 24) or "step",
+            "reason": _coerce_str(reason, 40) or "UNKNOWN",
+            "detail": scrub_text(detail),
+            "provider": _coerce_str(provider, 60),
+            "model": _coerce_str(model, 80),
+            "tool": _coerce_str(tool, 24),
+            "role": _coerce_str(role, 40),
+            "run_id": _coerce_str(run_id, 64),
+            "task_id": _coerce_str(task_id, 64),
+            "step": int(step or 0),
+            "exit_code": exit_code,
+            "app_version": _version()[:24],
+            "os": _os_tag(),
+        }
+        line = json.dumps(rec, ensure_ascii=False)
+        day = rec["day"]
+        with LOCK:
+            paths.ERRORS_DIR.mkdir(parents=True, exist_ok=True)
+            with open(paths.ERRORS_DIR / ("errors-%s.jsonl" % day[:7].replace("-", "")),
+                      "a", encoding="utf-8") as f:
+                f.write(line + "\n")
+    except Exception:
+        pass
+
+
+def iter_records(days=0):
+    """按时间范围读取台账（days=0 表示全部）。返回按写入顺序的记录列表。"""
+    out = []
+    try:
+        files = sorted(paths.ERRORS_DIR.glob("errors-*.jsonl")) if paths.ERRORS_DIR.is_dir() else []
+    except Exception:
+        return out
+    since_day = ""
+    if days:
+        import datetime
+        since_day = (datetime.date.today()
+                     - datetime.timedelta(days=int(days) - 1)).isoformat()
+    for p in files:
+        try:
+            for line in p.read_text(encoding="utf-8", errors="replace").splitlines():
+                line = line.strip()
+                if not line.startswith("{"):
+                    continue
+                try:
+                    r = json.loads(line)
+                except Exception:
+                    continue
+                if not isinstance(r, dict):
+                    continue
+                if since_day and str(r.get("day", "")) < since_day:
+                    continue
+                out.append(r)
+        except Exception:
+            continue
+    return out
+
+
+def pending_since(cursor, limit=200):
+    """取 cursor（上次上传到的记录 id）之后的记录，最多 limit 条。
+
+    id 以时间开头、uuid 尾巴保证唯一且字典序≈时间序；返回 (records, new_cursor)。
+    """
+    try:
+        recs = [r for r in iter_records(0) if str(r.get("id") or "") > str(cursor or "")]
+        recs.sort(key=lambda r: str(r.get("id") or ""))
+        batch = recs[:max(1, int(limit))]
+        new_cursor = str(batch[-1].get("id")) if batch else str(cursor or "")
+        return batch, new_cursor
+    except Exception:
+        return [], str(cursor or "")

package/app/core/evaluation.py

@@ -1,174 +1,174 @@
-# -*- coding: utf-8 -*-
-"""Expiring model/provider evaluation conclusions.
-
-An evaluation is evidence captured at a point in time, not a permanent
-capability claim.  Results are kept as a small, content-free local ledger so
-the UI or a router can distinguish a fresh ``passed`` result from an expired
-one.  A provider health failure invalidates matching conclusions immediately;
-the health probe can show recovery, but only a fresh evaluation restores
-``passed``.
-"""
-from __future__ import annotations
-
-import json
-import math
-import os
-from pathlib import Path
-import threading
-import time
-
-DEFAULT_TTL_SECONDS = 24 * 60 * 60
-_LOCK = threading.RLock()
-
-
-def _path() -> Path:
-    from . import paths
-    return Path(paths.DATA_DIR) / "evaluations.json"
-
-
-def ttl_seconds() -> float:
-    try:
-        return max(60.0, float(os.environ.get(
-            "TUTTI_EVALUATION_TTL_S", DEFAULT_TTL_SECONDS)))
-    except (TypeError, ValueError):
-        return float(DEFAULT_TTL_SECONDS)
-
-
-def _read() -> dict:
-    try:
-        value = json.loads(_path().read_text(encoding="utf-8"))
-        return value if isinstance(value, dict) else {}
-    except (OSError, json.JSONDecodeError):
-        return {}
-
-
-def _write(value: dict) -> None:
-    path = _path()
-    try:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        tmp = path.with_suffix(".tmp")
-        tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2),
-                       encoding="utf-8")
-        tmp.replace(path)
-    except OSError:
-        # Evaluation is telemetry.  A read-only data directory must not turn
-        # a successful model call into a task failure.
-        pass
-
-
-def key(kind: str, provider_id: str, model: str = "", protocol: str = "",
-        key_id: str = "") -> str:
-    base = "%s|%s|%s" % (str(kind or "provider"),
-                          str(provider_id or ""), str(model or ""))
-    suffix = "|".join((str(protocol or ""), str(key_id or "")))
-    return base if not suffix.strip("|") else base + "|" + suffix
-
-
-def decorate(result: dict, *, now=None) -> dict:
-    """Attach an evaluated-at timestamp and expiry to an API response."""
-    out = dict(result or {})
-    now = time.time() if now is None else float(now)
-    out["evaluated_at"] = now
-    out["expires_at"] = now + ttl_seconds()
-    out["fresh"] = True
-    return out
-
-
-def record(kind: str, provider_id: str, model: str, result: dict,
-           *, protocol: str = "", requested_model: str = "",
-           served_model: str = "", key_id: str = "") -> dict:
-    """Persist safe metadata for one completed evaluation and return it."""
-    out = decorate(result)
-    entry = {
-        "kind": str(kind or "provider"),
-        "provider_id": str(provider_id or ""),
-        "model": str(model or ""),
-        "status": str(out.get("status") or "failed"),
-        "ok": bool(out.get("ok")),
-        "evaluated_at": out["evaluated_at"],
-        "expires_at": out["expires_at"],
-        "protocol": str(protocol or ""),
-        "key_id": str(key_id or result.get("key_id") or ""),
-        "requested_model": str(requested_model or model or ""),
-        "served_model": str(served_model or ""),
-    }
-    with _LOCK:
-        data = _read()
-        data.setdefault("entries", {})[key(
-            kind, provider_id, model, protocol, key_id or result.get("key_id") or "")] = entry
-        _write(data)
-    return out
-
-
-def invalidate_provider(provider_id: str, model: str = "",
-                        *, reason: str = "health_failure") -> None:
-    """Invalidate one model, or all conclusions, after a health event."""
-    provider_id = str(provider_id or "").strip()
-    if not provider_id:
-        return
-    with _LOCK:
-        data = _read()
-        at = time.time()
-        invalidations = data.setdefault("invalidated", {})
-        invalidations[provider_id] = {
-            "at": at, "reason": str(reason or "health_failure")[:80]}
-        if model:
-            invalidations[key("model", provider_id, model)] = {
-                "at": at, "reason": str(reason or "health_failure")[:80]}
-        _write(data)
-
-
-def _safe_float(value, default=0.0) -> float:
-    try:
-        result = float(value)
-        return result if math.isfinite(result) else float(default)
-    except (TypeError, ValueError):
-        return float(default)
-
-
-def get(kind: str, provider_id: str, model: str = "", *, now=None):
-    """Read an evaluation, returning a stale marker after TTL/health expiry."""
-    now = time.time() if now is None else float(now)
-    with _LOCK:
-        data = _read()
-    entries = data.get("entries") or {}
-    base_key = key(kind, provider_id, model)
-    entry = entries.get(base_key)
-    matches = [value for name, value in entries.items()
-               if str(name).startswith(base_key + "|") and isinstance(value, dict)]
-    candidates = ([entry] if isinstance(entry, dict) else []) + matches
-    entry = max(candidates, key=lambda value: _safe_float(value.get("evaluated_at")),
-                default=None)
-    if not isinstance(entry, dict):
-        return None
-    out = dict(entry)
-    invalidated = data.get("invalidated") or {}
-    exact_invalid = invalidated.get(key(kind, provider_id, model)) or {}
-    provider_invalid = invalidated.get(str(provider_id or "")) or {}
-    invalid = max((candidate for candidate in (exact_invalid, provider_invalid)
-                   if isinstance(candidate, dict)),
-                  key=lambda candidate: _safe_float(candidate.get("at")),
-                  default={})
-    invalid_at = _safe_float(invalid.get("at"))
-    expires_at = _safe_float(out.get("expires_at"))
-    stale_reason = ""
-    if invalid_at and invalid_at >= _safe_float(out.get("evaluated_at")):
-        stale_reason = str(invalid.get("reason") or "health_failure")
-    elif expires_at <= now:
-        stale_reason = "ttl_expired"
-    if stale_reason:
-        out["fresh"] = False
-        out["ok"] = False
-        out["status"] = "stale"
-        out["stale_reason"] = stale_reason
-    else:
-        out["fresh"] = True
-    return out
-
-
-def reset_for_tests() -> None:
-    with _LOCK:
-        try:
-            _path().unlink()
-        except OSError:
-            pass
+# -*- coding: utf-8 -*-
+"""Expiring model/provider evaluation conclusions.
+
+An evaluation is evidence captured at a point in time, not a permanent
+capability claim.  Results are kept as a small, content-free local ledger so
+the UI or a router can distinguish a fresh ``passed`` result from an expired
+one.  A provider health failure invalidates matching conclusions immediately;
+the health probe can show recovery, but only a fresh evaluation restores
+``passed``.
+"""
+from __future__ import annotations
+
+import json
+import math
+import os
+from pathlib import Path
+import threading
+import time
+
+DEFAULT_TTL_SECONDS = 24 * 60 * 60
+_LOCK = threading.RLock()
+
+
+def _path() -> Path:
+    from . import paths
+    return Path(paths.DATA_DIR) / "evaluations.json"
+
+
+def ttl_seconds() -> float:
+    try:
+        return max(60.0, float(os.environ.get(
+            "TUTTI_EVALUATION_TTL_S", DEFAULT_TTL_SECONDS)))
+    except (TypeError, ValueError):
+        return float(DEFAULT_TTL_SECONDS)
+
+
+def _read() -> dict:
+    try:
+        value = json.loads(_path().read_text(encoding="utf-8"))
+        return value if isinstance(value, dict) else {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _write(value: dict) -> None:
+    path = _path()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2),
+                       encoding="utf-8")
+        tmp.replace(path)
+    except OSError:
+        # Evaluation is telemetry.  A read-only data directory must not turn
+        # a successful model call into a task failure.
+        pass
+
+
+def key(kind: str, provider_id: str, model: str = "", protocol: str = "",
+        key_id: str = "") -> str:
+    base = "%s|%s|%s" % (str(kind or "provider"),
+                          str(provider_id or ""), str(model or ""))
+    suffix = "|".join((str(protocol or ""), str(key_id or "")))
+    return base if not suffix.strip("|") else base + "|" + suffix
+
+
+def decorate(result: dict, *, now=None) -> dict:
+    """Attach an evaluated-at timestamp and expiry to an API response."""
+    out = dict(result or {})
+    now = time.time() if now is None else float(now)
+    out["evaluated_at"] = now
+    out["expires_at"] = now + ttl_seconds()
+    out["fresh"] = True
+    return out
+
+
+def record(kind: str, provider_id: str, model: str, result: dict,
+           *, protocol: str = "", requested_model: str = "",
+           served_model: str = "", key_id: str = "") -> dict:
+    """Persist safe metadata for one completed evaluation and return it."""
+    out = decorate(result)
+    entry = {
+        "kind": str(kind or "provider"),
+        "provider_id": str(provider_id or ""),
+        "model": str(model or ""),
+        "status": str(out.get("status") or "failed"),
+        "ok": bool(out.get("ok")),
+        "evaluated_at": out["evaluated_at"],
+        "expires_at": out["expires_at"],
+        "protocol": str(protocol or ""),
+        "key_id": str(key_id or result.get("key_id") or ""),
+        "requested_model": str(requested_model or model or ""),
+        "served_model": str(served_model or ""),
+    }
+    with _LOCK:
+        data = _read()
+        data.setdefault("entries", {})[key(
+            kind, provider_id, model, protocol, key_id or result.get("key_id") or "")] = entry
+        _write(data)
+    return out
+
+
+def invalidate_provider(provider_id: str, model: str = "",
+                        *, reason: str = "health_failure") -> None:
+    """Invalidate one model, or all conclusions, after a health event."""
+    provider_id = str(provider_id or "").strip()
+    if not provider_id:
+        return
+    with _LOCK:
+        data = _read()
+        at = time.time()
+        invalidations = data.setdefault("invalidated", {})
+        invalidations[provider_id] = {
+            "at": at, "reason": str(reason or "health_failure")[:80]}
+        if model:
+            invalidations[key("model", provider_id, model)] = {
+                "at": at, "reason": str(reason or "health_failure")[:80]}
+        _write(data)
+
+
+def _safe_float(value, default=0.0) -> float:
+    try:
+        result = float(value)
+        return result if math.isfinite(result) else float(default)
+    except (TypeError, ValueError):
+        return float(default)
+
+
+def get(kind: str, provider_id: str, model: str = "", *, now=None):
+    """Read an evaluation, returning a stale marker after TTL/health expiry."""
+    now = time.time() if now is None else float(now)
+    with _LOCK:
+        data = _read()
+    entries = data.get("entries") or {}
+    base_key = key(kind, provider_id, model)
+    entry = entries.get(base_key)
+    matches = [value for name, value in entries.items()
+               if str(name).startswith(base_key + "|") and isinstance(value, dict)]
+    candidates = ([entry] if isinstance(entry, dict) else []) + matches
+    entry = max(candidates, key=lambda value: _safe_float(value.get("evaluated_at")),
+                default=None)
+    if not isinstance(entry, dict):
+        return None
+    out = dict(entry)
+    invalidated = data.get("invalidated") or {}
+    exact_invalid = invalidated.get(key(kind, provider_id, model)) or {}
+    provider_invalid = invalidated.get(str(provider_id or "")) or {}
+    invalid = max((candidate for candidate in (exact_invalid, provider_invalid)
+                   if isinstance(candidate, dict)),
+                  key=lambda candidate: _safe_float(candidate.get("at")),
+                  default={})
+    invalid_at = _safe_float(invalid.get("at"))
+    expires_at = _safe_float(out.get("expires_at"))
+    stale_reason = ""
+    if invalid_at and invalid_at >= _safe_float(out.get("evaluated_at")):
+        stale_reason = str(invalid.get("reason") or "health_failure")
+    elif expires_at <= now:
+        stale_reason = "ttl_expired"
+    if stale_reason:
+        out["fresh"] = False
+        out["ok"] = False
+        out["status"] = "stale"
+        out["stale_reason"] = stale_reason
+    else:
+        out["fresh"] = True
+    return out
+
+
+def reset_for_tests() -> None:
+    with _LOCK:
+        try:
+            _path().unlink()
+        except OSError:
+            pass