codebee 0.1.66 → 0.1.68

package/app/core/tlsctx.py

@@ -1,64 +1,64 @@
-# -*- coding: utf-8 -*-
-"""HTTPS 证书校验上下文：补齐 macOS 上 Python 缺失的 CA 源（不关校验）。
-
-现象：用官方 pkg 装 Node 的 Mac 上往往再装 python.org 的 Python，它不读
-系统钥匙串，默认验证路径下没有根证书，所有 HTTPS 请求报
-CERTIFICATE_VERIFY_FAILED（unable to get local issuer certificate）。
-
-修法是给默认上下文**追加**可用 CA 源，校验语义只增不减：
-  1. certifi（装了就用，跨平台最全）；
-  2. /etc/ssl/cert.pem（macOS 系统自带 CA 束，Catalina 起就有）。
-两个都拿不到时返回默认上下文——报错与旧行为一致，绝不静默关校验。
-"""
-import ssl
-import sys
-
-
-def cafiles():
-    """候选 CA 束路径；坏路径/不存在由 load_verify_locations 抛错后被吞。"""
-    out = []
-    try:
-        import certifi
-        out.append(certifi.where())
-    except Exception:
-        pass
-    if sys.platform == "darwin":
-        out.append("/etc/ssl/cert.pem")
-    return out
-
-
-def _build():
-    ctx = ssl.create_default_context()
-    for f in cafiles():
-        try:
-            ctx.load_verify_locations(cafile=f)
-        except Exception:
-            pass
-    return ctx
-
-
-_CTX = None
-
-
-def context():
-    """带兜底 CA 源的 ssl.SSLContext（进程内缓存；校验语义与默认一致）。"""
-    global _CTX
-    if _CTX is None:
-        _CTX = _build()
-    return _CTX
-
-
-def humanize(err_text):
-    """证书验证失败 → 可行动的人话提示（非证书类错误原样返回）。
-
-    兜底 CA 仍验证失败只剩两类真实原因：本机代理对 HTTPS 做 TLS 拦截
-    （其根证书只在系统钥匙串/浏览器里，Python 的静态 CA 束不认），或极端
-    环境连 /etc/ssl/cert.pem 都没有。SSL_CERT_FILE 是 OpenSSL 标准逃生门，
-    create_default_context() 本就吃它，无需额外代码。"""
-    text = str(err_text or "")
-    if "CERTIFICATE_VERIFY_FAILED" not in text:
-        return text
-    return (text + " —— 证书验证仍失败：① 若开着代理/安全软件且开启了 HTTPS 拦截，"
-            "关掉拦截，或把其根证书导出后设环境变量 SSL_CERT_FILE 指向它再启动；"
-            "② 确认系统存在 /etc/ssl/cert.pem；③ 刚升级过 CodeBee 的话，"
-            "旧服务进程可能还在跑——关掉终端窗口重开")
+# -*- coding: utf-8 -*-
+"""HTTPS 证书校验上下文：补齐 macOS 上 Python 缺失的 CA 源（不关校验）。
+
+现象：用官方 pkg 装 Node 的 Mac 上往往再装 python.org 的 Python，它不读
+系统钥匙串，默认验证路径下没有根证书，所有 HTTPS 请求报
+CERTIFICATE_VERIFY_FAILED（unable to get local issuer certificate）。
+
+修法是给默认上下文**追加**可用 CA 源，校验语义只增不减：
+  1. certifi（装了就用，跨平台最全）；
+  2. /etc/ssl/cert.pem（macOS 系统自带 CA 束，Catalina 起就有）。
+两个都拿不到时返回默认上下文——报错与旧行为一致，绝不静默关校验。
+"""
+import ssl
+import sys
+
+
+def cafiles():
+    """候选 CA 束路径；坏路径/不存在由 load_verify_locations 抛错后被吞。"""
+    out = []
+    try:
+        import certifi
+        out.append(certifi.where())
+    except Exception:
+        pass
+    if sys.platform == "darwin":
+        out.append("/etc/ssl/cert.pem")
+    return out
+
+
+def _build():
+    ctx = ssl.create_default_context()
+    for f in cafiles():
+        try:
+            ctx.load_verify_locations(cafile=f)
+        except Exception:
+            pass
+    return ctx
+
+
+_CTX = None
+
+
+def context():
+    """带兜底 CA 源的 ssl.SSLContext（进程内缓存；校验语义与默认一致）。"""
+    global _CTX
+    if _CTX is None:
+        _CTX = _build()
+    return _CTX
+
+
+def humanize(err_text):
+    """证书验证失败 → 可行动的人话提示（非证书类错误原样返回）。
+
+    兜底 CA 仍验证失败只剩两类真实原因：本机代理对 HTTPS 做 TLS 拦截
+    （其根证书只在系统钥匙串/浏览器里，Python 的静态 CA 束不认），或极端
+    环境连 /etc/ssl/cert.pem 都没有。SSL_CERT_FILE 是 OpenSSL 标准逃生门，
+    create_default_context() 本就吃它，无需额外代码。"""
+    text = str(err_text or "")
+    if "CERTIFICATE_VERIFY_FAILED" not in text:
+        return text
+    return (text + " —— 证书验证仍失败：① 若开着代理/安全软件且开启了 HTTPS 拦截，"
+            "关掉拦截，或把其根证书导出后设环境变量 SSL_CERT_FILE 指向它再启动；"
+            "② 确认系统存在 /etc/ssl/cert.pem；③ 刚升级过 CodeBee 的话，"
+            "旧服务进程可能还在跑——关掉终端窗口重开")

package/app/core/token_meter.py

@@ -1,148 +1,148 @@
-# -*- coding: utf-8 -*-
-"""Token 压力估算：按 run 累计 usage，给出「已用/容量」压力比。
-
-设计稿：docs/migration/02-context-compaction.md §1C。
-参考 dsh packages/llm/token-meter/src/index.ts：滑动窗口 + usage 锚点 + 失败重定价。
-
-Tutti 简化实现：每 run 一个累计窗口（deque 有上限），usage 来自
-runner._parse_codex_jsonl / _parse_claude_json 已解析的字段；
-容量查 DEFAULT_CAPACITY 表（可被 data/model_capacity.json 覆盖）。
-"""
-from __future__ import annotations
-
-import json
-import logging
-import threading
-import time
-from collections import deque
-from pathlib import Path
-
-log = logging.getLogger(__name__)
-
-# 默认模型容量（token）。未命中 key 时用 "" 兜底行。
-DEFAULT_CAPACITY = {
-    "": 128_000,
-    "gpt-5": 400_000,
-    "gpt-5.5": 400_000,
-    "deepseek-chat": 128_000,
-    "deepseek-reasoner": 64_000,
-    "qwen3-max": 256_000,
-    "qwen3.8-flash": 256_000,
-}
-
-# 压缩触发阈值（设计稿 §1B 默认 0.8，可被 orchestration.json 覆盖）
-DEFAULT_PRESSURE_THRESHOLD = 0.8
-
-# 容量覆盖文件（热改立即生效）
-_CAPACITY_FILE = Path(__file__).resolve().parents[2] / "data" / "model_capacity.json"
-
-
-def _load_capacity():
-    """默认表 + 可选覆盖文件合并。文件缺失/坏 JSON 静默用默认。"""
-    cap = dict(DEFAULT_CAPACITY)
-    try:
-        if _CAPACITY_FILE.is_file():
-            data = json.loads(_CAPACITY_FILE.read_text(encoding="utf-8"))
-            if isinstance(data, dict):
-                cap.update({str(k): int(v) for k, v in data.items()})
-    except Exception:
-        pass
-    return cap
-
-
-class TokenMeter:
-    """每 run 独立累计窗口；线程安全。"""
-
-    def __init__(self, capacity=None, *, window_size=200):
-        self._capacity_override = capacity
-        self._window_size = window_size
-        self._lock = threading.Lock()
-        # run_id -> deque[(ts, input, output, reasoning, cached)]
-        self._windows: dict = {}
-        # run_id -> 最后一次见到的 model 名（pressure_ratio 未显式传 model 时用）
-        self._last_model: dict = {}
-        self._cap_cache = None
-        self._cap_mtime = 0.0
-
-    def _capacity(self):
-        """容量表（带 mtime 缓存，热改 data/model_capacity.json 立即生效）。"""
-        try:
-            mtime = _CAPACITY_FILE.stat().st_mtime
-        except OSError:
-            mtime = 0.0
-        if self._cap_cache is None or mtime != self._cap_mtime:
-            if self._capacity_override is not None:
-                self._cap_cache = dict(self._capacity_override)
-            else:
-                self._cap_cache = _load_capacity()
-            self._cap_mtime = mtime
-        return self._cap_cache
-
-    def accumulate(self, run_id: str, usage, model: str = ""):
-        """记录一次调用的 usage。usage 字段缺失按 0 处理；usage=None 跳过。
-
-        cached 单独记录但不计入 used()——缓存读不占新一轮上下文压力
-        （与 runner._parse_claude_json 的口径一致：cached 是省钱的部分）。
-        """
-        if not usage:
-            return
-        with self._lock:
-            if model:
-                self._last_model[run_id] = model
-            window = self._windows.setdefault(run_id, deque(maxlen=self._window_size))
-            window.append((
-                time.time(),
-                int(usage.get("input") or 0),
-                int(usage.get("output") or 0),
-                int(usage.get("reasoning") or 0),
-                int(usage.get("cached") or 0),
-            ))
-
-    def used(self, run_id: str) -> int:
-        """窗口内累计（input + output + reasoning），不含 cached。"""
-        with self._lock:
-            window = self._windows.get(run_id)
-            if not window:
-                return 0
-            return sum(i + o + r for _, i, o, r, _ in window)
-
-    def cached(self, run_id: str) -> int:
-        with self._lock:
-            window = self._windows.get(run_id)
-            if not window:
-                return 0
-            return sum(c for _, _, _, _, c in window)
-
-    def pressure_ratio(self, run_id: str, model: str = "") -> float:
-        """已用 / 容量。model 未传时用该 run 最后一次见到的模型名。"""
-        cap_table = self._capacity()
-        with self._lock:
-            m = model or self._last_model.get(run_id, "")
-        cap = cap_table.get(m, cap_table.get("", 128_000))
-        return self.used(run_id) / max(cap, 1)
-
-    def capacity(self, model: str = "") -> int:
-        """模型上下文容量（未命中用默认行）。"""
-        cap_table = self._capacity()
-        return cap_table.get(model or "", cap_table.get("", 128_000))
-
-    def last_context(self, run_id: str) -> int:
-        """最近一次调用的 input+output+reasoning——下个请求要重发的上下文锚点。
-
-        used() 是窗口累计（多次调用叠加，系统性偏大，适合做响应式预算闸）；
-        事前预检判断「这个请求会不会被拒」要用最近一次的真实上下文体量，
-        两者口径不同不可混用（借鉴 freebuff base-chat 每步容量重估）。"""
-        with self._lock:
-            window = self._windows.get(run_id)
-            if not window:
-                return 0
-            _, i, o, r, _ = window[-1]
-            return i + o + r
-
-    def reset(self, run_id: str):
-        with self._lock:
-            self._windows.pop(run_id, None)
-            self._last_model.pop(run_id, None)
-
-
+# -*- coding: utf-8 -*-
+"""Token 压力估算：按 run 累计 usage，给出「已用/容量」压力比。
+
+设计稿：docs/migration/02-context-compaction.md §1C。
+参考 dsh packages/llm/token-meter/src/index.ts：滑动窗口 + usage 锚点 + 失败重定价。
+
+Tutti 简化实现：每 run 一个累计窗口（deque 有上限），usage 来自
+runner._parse_codex_jsonl / _parse_claude_json 已解析的字段；
+容量查 DEFAULT_CAPACITY 表（可被 data/model_capacity.json 覆盖）。
+"""
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+from collections import deque
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+# 默认模型容量（token）。未命中 key 时用 "" 兜底行。
+DEFAULT_CAPACITY = {
+    "": 128_000,
+    "gpt-5": 400_000,
+    "gpt-5.5": 400_000,
+    "deepseek-chat": 128_000,
+    "deepseek-reasoner": 64_000,
+    "qwen3-max": 256_000,
+    "qwen3.8-flash": 256_000,
+}
+
+# 压缩触发阈值（设计稿 §1B 默认 0.8，可被 orchestration.json 覆盖）
+DEFAULT_PRESSURE_THRESHOLD = 0.8
+
+# 容量覆盖文件（热改立即生效）
+_CAPACITY_FILE = Path(__file__).resolve().parents[2] / "data" / "model_capacity.json"
+
+
+def _load_capacity():
+    """默认表 + 可选覆盖文件合并。文件缺失/坏 JSON 静默用默认。"""
+    cap = dict(DEFAULT_CAPACITY)
+    try:
+        if _CAPACITY_FILE.is_file():
+            data = json.loads(_CAPACITY_FILE.read_text(encoding="utf-8"))
+            if isinstance(data, dict):
+                cap.update({str(k): int(v) for k, v in data.items()})
+    except Exception:
+        pass
+    return cap
+
+
+class TokenMeter:
+    """每 run 独立累计窗口；线程安全。"""
+
+    def __init__(self, capacity=None, *, window_size=200):
+        self._capacity_override = capacity
+        self._window_size = window_size
+        self._lock = threading.Lock()
+        # run_id -> deque[(ts, input, output, reasoning, cached)]
+        self._windows: dict = {}
+        # run_id -> 最后一次见到的 model 名（pressure_ratio 未显式传 model 时用）
+        self._last_model: dict = {}
+        self._cap_cache = None
+        self._cap_mtime = 0.0
+
+    def _capacity(self):
+        """容量表（带 mtime 缓存，热改 data/model_capacity.json 立即生效）。"""
+        try:
+            mtime = _CAPACITY_FILE.stat().st_mtime
+        except OSError:
+            mtime = 0.0
+        if self._cap_cache is None or mtime != self._cap_mtime:
+            if self._capacity_override is not None:
+                self._cap_cache = dict(self._capacity_override)
+            else:
+                self._cap_cache = _load_capacity()
+            self._cap_mtime = mtime
+        return self._cap_cache
+
+    def accumulate(self, run_id: str, usage, model: str = ""):
+        """记录一次调用的 usage。usage 字段缺失按 0 处理；usage=None 跳过。
+
+        cached 单独记录但不计入 used()——缓存读不占新一轮上下文压力
+        （与 runner._parse_claude_json 的口径一致：cached 是省钱的部分）。
+        """
+        if not usage:
+            return
+        with self._lock:
+            if model:
+                self._last_model[run_id] = model
+            window = self._windows.setdefault(run_id, deque(maxlen=self._window_size))
+            window.append((
+                time.time(),
+                int(usage.get("input") or 0),
+                int(usage.get("output") or 0),
+                int(usage.get("reasoning") or 0),
+                int(usage.get("cached") or 0),
+            ))
+
+    def used(self, run_id: str) -> int:
+        """窗口内累计（input + output + reasoning），不含 cached。"""
+        with self._lock:
+            window = self._windows.get(run_id)
+            if not window:
+                return 0
+            return sum(i + o + r for _, i, o, r, _ in window)
+
+    def cached(self, run_id: str) -> int:
+        with self._lock:
+            window = self._windows.get(run_id)
+            if not window:
+                return 0
+            return sum(c for _, _, _, _, c in window)
+
+    def pressure_ratio(self, run_id: str, model: str = "") -> float:
+        """已用 / 容量。model 未传时用该 run 最后一次见到的模型名。"""
+        cap_table = self._capacity()
+        with self._lock:
+            m = model or self._last_model.get(run_id, "")
+        cap = cap_table.get(m, cap_table.get("", 128_000))
+        return self.used(run_id) / max(cap, 1)
+
+    def capacity(self, model: str = "") -> int:
+        """模型上下文容量（未命中用默认行）。"""
+        cap_table = self._capacity()
+        return cap_table.get(model or "", cap_table.get("", 128_000))
+
+    def last_context(self, run_id: str) -> int:
+        """最近一次调用的 input+output+reasoning——下个请求要重发的上下文锚点。
+
+        used() 是窗口累计（多次调用叠加，系统性偏大，适合做响应式预算闸）；
+        事前预检判断「这个请求会不会被拒」要用最近一次的真实上下文体量，
+        两者口径不同不可混用（借鉴 freebuff base-chat 每步容量重估）。"""
+        with self._lock:
+            window = self._windows.get(run_id)
+            if not window:
+                return 0
+            _, i, o, r, _ = window[-1]
+            return i + o + r
+
+    def reset(self, run_id: str):
+        with self._lock:
+            self._windows.pop(run_id, None)
+            self._last_model.pop(run_id, None)
+
+
 token_meter = TokenMeter()  # 单例

package/app/core/tracing.py

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+"""Run/step/event tracing primitives.
+
+The shape intentionally follows OpenTelemetry/OpenInference's trace -> span
+relationship without adding a third-party dependency.  It is a read model of
+the existing run and dispatch ledgers: no prompt, stdout, stderr, credentials,
+or artifact contents are copied into the trace.
+"""
+from __future__ import annotations
+
+import hashlib
+from datetime import datetime
+
+from .redact import scrub_text
+
+
+SCHEMA_VERSION = 1
+
+
+def _stable(prefix: str, *parts: object, length: int = 32) -> str:
+    raw = prefix + ":" + ":".join(str(part or "") for part in parts)
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:length]
+
+
+def trace_id(run_id: object) -> str:
+    """Return a deterministic 128-bit trace id for a run."""
+    return _stable("codebee.trace", run_id, length=32)
+
+
+def root_span_id(run_id: object) -> str:
+    return _stable("codebee.root", run_id, length=16)
+
+
+def span_id(run_id: object, step_no: object) -> str:
+    return _stable("codebee.step", run_id, step_no, length=16)
+
+
+def event_id(run_id: object, event: dict) -> str:
+    """Stable event id used for deduplication during replay."""
+    return _stable(
+        "codebee.event",
+        run_id,
+        event.get("ts"),
+        event.get("phase"),
+        event.get("role"),
+        event.get("selected"),
+        event.get("result"),
+        length=24,
+    )
+
+
+def _epoch(value):
+    if value is None or isinstance(value, (int, float)):
+        return value
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        return datetime.fromisoformat(text.replace("Z", "+00:00")).timestamp()
+    except (TypeError, ValueError, OverflowError):
+        return None
+
+
+def _duration(step: dict):
+    try:
+        value = float(step.get("duration_s"))
+        return round(max(0.0, value), 3)
+    except (TypeError, ValueError):
+        started = _epoch(step.get("started_at_epoch"))
+        ended = _epoch(step.get("ended_at_epoch"))
+        if started is not None and ended is not None:
+            return round(max(0.0, ended - started), 3)
+    return None
+
+
+def _safe_event(event: dict, run_id: str) -> dict:
+    """Keep only routing metadata from a dispatch event."""
+    allowed = (
+        "ts", "task_id", "task_type", "difficulty", "role", "phase",
+        "selected", "participants", "candidates", "fallback",
+        "selection_reason", "result", "verify_pass", "review_pass",
+        "trace_id", "span_id", "parent_event_id", "event_id",
+    )
+    item = {key: event[key] for key in allowed if key in event}
+    item.setdefault("trace_id", trace_id(run_id))
+    item.setdefault("event_id", event_id(run_id, item))
+    return _redact(item)
+
+
+def _redact(value, limit=600):
+    """Redact strings even when a legacy event predates dispatch_log scrub."""
+    if isinstance(value, dict):
+        return {key: _redact(item, 240) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_redact(item, 240) for item in value]
+    if isinstance(value, str):
+        return scrub_text(value, limit=limit)
+    return value
+
+
+def build_trace(run: dict, events=()) -> dict:
+    """Build a stable, redacted trace view from an existing run dictionary."""
+    run_id = str(run.get("id") or "")
+    tid = str(run.get("trace_id") or trace_id(run_id))
+    rid = str(run.get("root_span_id") or root_span_id(run_id))
+    spans = []
+    for step in run.get("steps") or ():
+        if not isinstance(step, dict):
+            continue
+        try:
+            number = int(step.get("n"))
+        except (TypeError, ValueError):
+            continue
+        span = {
+            "trace_id": tid,
+            "span_id": str(step.get("span_id") or span_id(run_id, number)),
+            "parent_span_id": str(step.get("parent_span_id") or rid),
+            "name": "agent.%s" % str(step.get("role") or "step")[:80],
+            "step": number,
+            "status": str(step.get("status") or "unknown"),
+            "agent": str(step.get("agent") or "")[:80],
+            "model": str(step.get("model") or "")[:120],
+            "provider": str(step.get("provider") or "")[:120],
+            "started_at": step.get("started_at_epoch"),
+            "ended_at": step.get("ended_at_epoch"),
+            "duration_s": _duration(step),
+            "tokens": step.get("tokens", 0),
+            "cost_usd": step.get("cost_usd", 0.0),
+            "exit_code": step.get("exit_code"),
+        }
+        spans.append(span)
+    safe_events = [_safe_event(item, run_id) for item in (events or ())
+                   if isinstance(item, dict)]
+    return {
+        "version": SCHEMA_VERSION,
+        "trace_id": tid,
+        "root_span_id": rid,
+        "run_id": run_id,
+        "status": str(run.get("status") or "unknown"),
+        "started_at": run.get("started_at"),
+        "ended_at": run.get("ended_at"),
+        "spans": spans,
+        "events": safe_events,
+    }

package/app/core/upstream.py

@@ -1,41 +1,41 @@
-# -*- coding: utf-8 -*-
-"""Shared upstream identity normalization for routing and retry guards."""
-from __future__ import annotations
-
-import ipaddress
-from urllib.parse import urlsplit
-
-
-def normalize_upstream(value, default_scheme="https"):
-    """Return a stable host[:port] identity, without URL path or credentials.
-
-    Host names are case-insensitive and a trailing dot is equivalent to the
-    non-dotted form. Default HTTP(S) ports are omitted so equivalent URLs share
-    one failure/permission bucket. Non-default ports remain distinct.
-    """
-    raw = str(value or "").strip()
-    if not raw:
-        return ""
-    candidate = raw if "://" in raw else "%s://%s" % (default_scheme, raw)
-    try:
-        parsed = urlsplit(candidate)
-        host = parsed.hostname
-        if not host:
-            return ""
-        host = host.rstrip(".").lower()
-        ip_host = None
-        try:
-            ip_host = ipaddress.ip_address(host)
-            host = ip_host.compressed.lower()
-        except ValueError:
-            pass
-        port = parsed.port
-        scheme = (parsed.scheme or default_scheme).lower()
-        if port is not None and not ((scheme == "https" and port == 443)
-                                     or (scheme == "http" and port == 80)):
-            if getattr(ip_host, "version", None) == 6:
-                return "[%s]:%d" % (host, port)
-            return "%s:%d" % (host, port)
-        return host
-    except (TypeError, ValueError):
-        return ""
+# -*- coding: utf-8 -*-
+"""Shared upstream identity normalization for routing and retry guards."""
+from __future__ import annotations
+
+import ipaddress
+from urllib.parse import urlsplit
+
+
+def normalize_upstream(value, default_scheme="https"):
+    """Return a stable host[:port] identity, without URL path or credentials.
+
+    Host names are case-insensitive and a trailing dot is equivalent to the
+    non-dotted form. Default HTTP(S) ports are omitted so equivalent URLs share
+    one failure/permission bucket. Non-default ports remain distinct.
+    """
+    raw = str(value or "").strip()
+    if not raw:
+        return ""
+    candidate = raw if "://" in raw else "%s://%s" % (default_scheme, raw)
+    try:
+        parsed = urlsplit(candidate)
+        host = parsed.hostname
+        if not host:
+            return ""
+        host = host.rstrip(".").lower()
+        ip_host = None
+        try:
+            ip_host = ipaddress.ip_address(host)
+            host = ip_host.compressed.lower()
+        except ValueError:
+            pass
+        port = parsed.port
+        scheme = (parsed.scheme or default_scheme).lower()
+        if port is not None and not ((scheme == "https" and port == 443)
+                                     or (scheme == "http" and port == 80)):
+            if getattr(ip_host, "version", None) == 6:
+                return "[%s]:%d" % (host, port)
+            return "%s:%d" % (host, port)
+        return host
+    except (TypeError, ValueError):
+        return ""