coze_lab 0.1.26 → 0.1.27

package/index.js

@@ -103,6 +103,18 @@ function successBox(lines) {
 // ─── 2. Script loading (scripts live as real files under ./scripts) ───────────
 const SCRIPTS_DIR = require('path').join(__dirname, 'scripts');
 
+// OpenClaw 插件版本：来自 scripts/openclaw/package.json。写进 openclaw.json 的 pcfg，
+// 参与 isOpenClawAlreadyInjected 幂等比对——插件代码升级（bump 该 version）后即使
+// token/endpoint/workspace 不变也会被判定为“需更新”，强制重写插件文件 + npm install +
+// gateway restart，避免旧插件 dist 滞留在云端 pluginDir 里不生效。
+const OPENCLAW_PLUGIN_VERSION = (() => {
+  try {
+    return require('./scripts/openclaw/package.json').version || '';
+  } catch {
+    return '';
+  }
+})();
+
 // Read a single script file (Python hook / refresh) as a UTF-8 string.
 function readScript(relPath) {
   return require('fs').readFileSync(require('path').join(SCRIPTS_DIR, relPath), 'utf8');
@@ -4378,28 +4390,34 @@ function checkPython() {
   return pythonCmd;
 }
 
-// Verify the `cozeloop` Python SDK is importable; auto-install if missing.
-// Claude Code / Codex hooks `import cozeloop` at runtime — without it the
-// first Stop hook fails with "cozeloop SDK not found" long after onboarding.
+// Verify the `cozeloop` Python SDK is importable AND new enough; install/upgrade otherwise.
+// Claude Code / Codex hooks `import cozeloop` at runtime and call set_finish_time（0.1.25+）。
+// 旧版（<=0.1.24）能 import 但缺该方法，会让 hook 上报整条 trace 失败，所以这里用能力探测
+// （hasattr set_finish_time）而非单纯 import，并在不达标时升级到带下限的版本。
+// 注意：这是安装阶段的 python，可能不是跑 hook 的那个 python（已知坑），所以它只是双保险——
+// 真正的运行时拦截在 hook 脚本的 _ensure_cozeloop_sdk 里。
+const COZELOOP_MIN_SPEC = 'cozeloop>=0.1.28';
+// 探测脚本：import 成功且具备 set_finish_time 能力 → exit 0；否则非 0。
+const COZELOOP_CAPABLE_PROBE = `import cozeloop,sys; sys.exit(0 if hasattr(cozeloop.Span,'set_finish_time') else 3)`;
 function checkCozeloopSdk(pythonCmd) {
   try {
-    execSync(`${pythonCmd} -c "import cozeloop"`, { stdio: 'pipe' });
+    execSync(`${pythonCmd} -c "${COZELOOP_CAPABLE_PROBE}"`, { stdio: 'pipe' });
     ok('cozeloop SDK — OK');
     return;
-  } catch { /* not installed — try to install below */ }
+  } catch { /* 未装或版本过旧 — 下面安装/升级 */ }
 
-  info('cozeloop SDK 未安装，正在安装 (pip install cozeloop)...');
+  info(`cozeloop SDK 不可用或版本过旧，正在安装/升级 (pip install -U '${COZELOOP_MIN_SPEC}')...`);
   try {
-    execSync(`${pythonCmd} -m pip install --quiet --upgrade cozeloop`, { stdio: 'pipe' });
-    // Confirm it imports now
-    execSync(`${pythonCmd} -c "import cozeloop"`, { stdio: 'pipe' });
-    ok('cozeloop SDK 安装成功');
+    execSync(`${pythonCmd} -m pip install --quiet --upgrade '${COZELOOP_MIN_SPEC}'`, { stdio: 'pipe' });
+    // Confirm it imports and is capable now
+    execSync(`${pythonCmd} -c "${COZELOOP_CAPABLE_PROBE}"`, { stdio: 'pipe' });
+    ok('cozeloop SDK 安装/升级成功');
   } catch (e) {
     warnBox([
-      '⚠ WARNING: 无法自动安装 cozeloop SDK',
+      '⚠ WARNING: 无法自动安装/升级 cozeloop SDK 到所需版本',
       '',
       '请手动安装后再使用，否则 hook 触发时 trace 上报会失败：',
-      `  ${pythonCmd} -m pip install cozeloop`,
+      `  ${pythonCmd} -m pip install -U '${COZELOOP_MIN_SPEC}'`,
       '',
       (e.stderr ? e.stderr.toString().trim() : e.message),
     ]);
@@ -4772,6 +4790,11 @@ function applyOpenClawPluginConfig(existing, token, workspaceId, agentId, cloud)
   pcfg.endpoint      = getOtelEndpointBase(cloud);
   pcfg.workspaceId   = workspaceId;
   pcfg.debug         = true;
+  // 插件代码版本：参与幂等比对，升级插件（bump scripts/openclaw/package.json version）后
+  // 强制触发重写+重装+重启，避免云端 pluginDir 滞留旧插件 dist。
+  if (OPENCLAW_PLUGIN_VERSION) {
+    pcfg.pluginVersion = OPENCLAW_PLUGIN_VERSION;
+  }
   // per-agent trace 放行：把当前 agentId 并入 traceAgentIds（去重、归一为小写，
   // 与插件侧 resolveAgentIdFromHookCtx 的归一一致）。无 agentId（全局模式）则不动
   // allowlist —— 空 allowlist 表示全部放行。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "Configure local AI agents (Claude Code, Codex, OpenClaw) to report traces to CozeLoop",
   "keywords": [
     "cozeloop",

package/scripts/claude-code/cozeloop_hook.py

@@ -29,19 +29,43 @@ from pathlib import Path
 from typing import Optional, List, Dict, Any
 
 # --- SDK Import ---
-def _ensure_cozeloop_sdk():
+# 最低版本：set_finish_time 是 cozeloop SDK 0.1.25 才引入的方法，云端预装旧版（<=0.1.24）
+# 调用会抛 AttributeError 并使整条 trace 上报失败。统一用能力探测（hasattr）判定，与
+# _set_finish_time_safe 兜底口径一致，避免版本号字符串比较的边界问题。
+_MIN_COZELOOP_SPEC = "cozeloop>=0.1.28"
+
+
+def _cozeloop_capable():
+    """已装 cozeloop 是否具备 set_finish_time 能力。未装/异常返回 None（无法判定）。"""
     try:
         import cozeloop  # noqa: F401
-        return True
     except ImportError:
-        pass
+        return None
+    try:
+        return hasattr(cozeloop.Span, "set_finish_time")
+    except Exception:
+        return False
+
+
+def _ensure_cozeloop_sdk():
+    """确保 cozeloop 可 import 且尽量满足 set_finish_time 能力。
+
+    返回 True 表示 cozeloop 可 import（不保证版本达标——能力不足时由
+    _set_finish_time_safe 兜底，不阻断上报）；返回 False 表示完全无法 import。
+    """
+    capable = _cozeloop_capable()
+    if capable is True:
+        return True
+    # 已装但能力不足（capable is False）→ 需升级；未装（None）→ 需安装。
     import subprocess
     import importlib
     import site
+    pkg = _MIN_COZELOOP_SPEC
+    base_flags = ["--quiet", "--disable-pip-version-check", "--upgrade"]
     attempts = (
-        ["--quiet", "--disable-pip-version-check", "cozeloop"],
-        ["--quiet", "--disable-pip-version-check", "--break-system-packages", "cozeloop"],
-        ["--quiet", "--disable-pip-version-check", "--break-system-packages", "--user", "cozeloop"],
+        [*base_flags, pkg],
+        [*base_flags, "--break-system-packages", pkg],
+        [*base_flags, "--break-system-packages", "--user", pkg],
     )
     for extra in attempts:
         try:
@@ -60,11 +84,12 @@ def _ensure_cozeloop_sdk():
                     sys.path.insert(0, p)
             importlib.invalidate_caches()
             import cozeloop  # noqa: F401
-            print("[CozeLoop] cozeloop SDK auto-installed at runtime.", file=sys.stderr)
+            print("[CozeLoop] cozeloop SDK installed/upgraded at runtime.", file=sys.stderr)
             return True
         except ImportError:
             continue
-    return False
+    # 升级没成功，但只要原本能 import（capable is False）就继续——兜底会处理能力缺失。
+    return capable is False
 
 
 if _ensure_cozeloop_sdk():
@@ -539,6 +564,23 @@ def _ts_ms(dt):
     return int(dt.timestamp() * 1000) if dt is not None else None
 
 
+def _set_finish_time_safe(span, dt):
+    """安全设置 span 结束时间。
+
+    set_finish_time 是 cozeloop SDK 0.1.25+ 的方法，云端旧版没有；缺失或异常都不能
+    让整条 trace 上报失败（real_*_ms tag 仍保留耗时信息）。
+    """
+    if dt is None:
+        return
+    fn = getattr(span, "set_finish_time", None)
+    if fn is None:
+        return
+    try:
+        fn(dt)
+    except Exception:
+        pass
+
+
 def group_messages_into_turns(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Group messages into conversation turns (user -> assistant -> tool_results).
 
@@ -926,7 +968,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
             }
             # 真实耗时写 tag（SDK finish 不支持显式结束时间，duration 用 tag 兜底）
             if root_start_dt is not None and root_end_dt is not None:
-                root_span.set_finish_time(root_end_dt)
+                _set_finish_time_safe(root_span, root_end_dt)
                 root_tags["real_start_ms"] = _ts_ms(root_start_dt)
                 root_tags["real_end_ms"] = _ts_ms(root_end_dt)
                 root_tags["latency_ms"] = _ts_ms(root_end_dt) - _ts_ms(root_start_dt)
@@ -985,7 +1027,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                             "source": "claude_code",
                         }
                         if turn_start_dt is not None and turn_end_dt is not None:
-                            turn_span.set_finish_time(turn_end_dt)
+                            _set_finish_time_safe(turn_span, turn_end_dt)
                             _turn_tags["real_start_ms"] = _ts_ms(turn_start_dt)
                             _turn_tags["real_end_ms"] = _ts_ms(turn_end_dt)
                             _turn_tags["latency_ms"] = _ts_ms(turn_end_dt) - _ts_ms(turn_start_dt)
@@ -1019,7 +1061,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                 model_span.set_runtime(Runtime(library="claude-code"))
                                 model_span.set_model_name(model_name)
                                 if step_start_dt is not None and step_end_dt is not None:
-                                    model_span.set_finish_time(step_end_dt)
+                                    _set_finish_time_safe(model_span, step_end_dt)
                                     model_span.set_tags({
                                         "real_start_ms": _ts_ms(step_start_dt),
                                         "real_end_ms": _ts_ms(step_end_dt),
@@ -1132,7 +1174,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                     tool_span.set_runtime(Runtime(library="claude-code"))
                                     # 设真实完成时间，让每个 tool 的 duration 反映实际耗时。
                                     if tool_end_dt is not None:
-                                        tool_span.set_finish_time(tool_end_dt)
+                                        _set_finish_time_safe(tool_span, tool_end_dt)
                                     tags = {
                                         "tool_name": tool_name,
                                         "tool_call_id": tool_call.get("id"),

package/scripts/codex/cozeloop_hook.py

@@ -249,19 +249,44 @@ def get_fresh_token():
 # -------------------------------------------------------------------------
 
 # --- SDK Import ---
-def _ensure_cozeloop_sdk():
+# 最低版本：set_finish_time 是 cozeloop SDK 0.1.25 才引入的方法，云端预装旧版（<=0.1.24）
+# 调用会抛 AttributeError 并使整条 trace 上报失败。统一用能力探测（hasattr）判定，与
+# _set_finish_time_safe 兜底口径一致，避免版本号字符串比较的边界问题。
+_MIN_COZELOOP_SPEC = "cozeloop>=0.1.28"
+
+
+def _cozeloop_capable():
+    """已装 cozeloop 是否具备 set_finish_time 能力。未装/异常返回 None（无法判定）。"""
     try:
         import cozeloop  # noqa: F401
-        return True
     except ImportError:
-        pass
+        return None
+    try:
+        return hasattr(cozeloop.Span, "set_finish_time")
+    except Exception:
+        return False
+
+
+def _ensure_cozeloop_sdk():
+    """确保 cozeloop 可 import 且尽量满足 set_finish_time 能力。
+
+    返回 True 表示 cozeloop 可 import（不保证版本达标——能力不足时由
+    _set_finish_time_safe 兜底，不阻断上报）；返回 False 表示完全无法 import。
+    """
+    capable = _cozeloop_capable()
+    if capable is True:
+        return True
+    # 已装但能力不足（capable is False）→ 需升级；未装（None）→ 需安装。
     import subprocess
     import importlib
     import site
+    # 能力不足时强制升级到带下限的版本；未装时直接装下限版本。
+    pkg = _MIN_COZELOOP_SPEC
+    base_flags = ["--quiet", "--disable-pip-version-check", "--upgrade"]
     attempts = (
-        ["--quiet", "--disable-pip-version-check", "cozeloop"],
-        ["--quiet", "--disable-pip-version-check", "--break-system-packages", "cozeloop"],
-        ["--quiet", "--disable-pip-version-check", "--break-system-packages", "--user", "cozeloop"],
+        [*base_flags, pkg],
+        [*base_flags, "--break-system-packages", pkg],
+        [*base_flags, "--break-system-packages", "--user", pkg],
     )
     for extra in attempts:
         try:
@@ -280,11 +305,12 @@ def _ensure_cozeloop_sdk():
                     sys.path.insert(0, p)
             importlib.invalidate_caches()
             import cozeloop  # noqa: F401
-            print("[CozeLoop] cozeloop SDK auto-installed at runtime.", file=sys.stderr)
+            print("[CozeLoop] cozeloop SDK installed/upgraded at runtime.", file=sys.stderr)
             return True
         except ImportError:
             continue
-    return False
+    # 升级没成功，但只要原本能 import（capable is False）就继续——兜底会处理能力缺失。
+    return capable is False
 
 
 if _ensure_cozeloop_sdk():
@@ -640,6 +666,23 @@ def _ts_ms(dt):
     return int(dt.timestamp() * 1000) if dt is not None else None
 
 
+def _set_finish_time_safe(span, dt):
+    """安全设置 span 结束时间。
+
+    set_finish_time 是 cozeloop SDK 0.1.25+ 的方法，云端旧版没有；缺失或异常都不能
+    让整条 trace 上报失败（real_*_ms tag 仍保留耗时信息）。
+    """
+    if dt is None:
+        return
+    fn = getattr(span, "set_finish_time", None)
+    if fn is None:
+        return
+    try:
+        fn(dt)
+    except Exception:
+        pass
+
+
 def _max_dt(*values):
     result = None
     for value in values:
@@ -955,7 +998,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                 "source": "codex_cli",
             }
             if root_start_dt is not None and root_end_dt is not None:
-                root_span.set_finish_time(root_end_dt)
+                _set_finish_time_safe(root_span, root_end_dt)
                 root_tags["real_start_ms"] = _ts_ms(root_start_dt)
                 root_tags["real_end_ms"] = _ts_ms(root_end_dt)
                 root_tags["latency_ms"] = _ts_ms(root_end_dt) - _ts_ms(root_start_dt)
@@ -1008,7 +1051,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                             "source": "codex_cli",
                         }
                         if turn_start_dt is not None and turn_end_dt is not None:
-                            turn_span.set_finish_time(turn_end_dt)
+                            _set_finish_time_safe(turn_span, turn_end_dt)
                             _turn_tags["real_start_ms"] = _ts_ms(turn_start_dt)
                             _turn_tags["real_end_ms"] = _ts_ms(turn_end_dt)
                             _turn_tags["latency_ms"] = _ts_ms(turn_end_dt) - _ts_ms(turn_start_dt)
@@ -1026,7 +1069,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                 model_span.set_runtime(Runtime(library="codex-cli"))
                                 model_span.set_model_name(model_name)
                                 if _model_start_dt is not None and _model_end_dt is not None:
-                                    model_span.set_finish_time(_model_end_dt)
+                                    _set_finish_time_safe(model_span, _model_end_dt)
                                     model_span.set_tags({
                                         "real_start_ms": _ts_ms(_model_start_dt),
                                         "real_end_ms": _ts_ms(_model_end_dt),
@@ -1114,7 +1157,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                     "call_id": call_id,
                                 }
                                 if tool_start_dt is not None and tool_finish_dt is not None:
-                                    tool_span.set_finish_time(tool_finish_dt)
+                                    _set_finish_time_safe(tool_span, tool_finish_dt)
                                     tool_tags["real_start_ms"] = _ts_ms(tool_start_dt)
                                     tool_tags["real_end_ms"] = _ts_ms(tool_finish_dt)
                                     tool_tags["latency_ms"] = _ts_ms(tool_finish_dt) - _ts_ms(tool_start_dt)
@@ -1148,7 +1191,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                     "agent_model": sc.get("model") or "",
                                 }
                                 if subagent_start_dt is not None and subagent_finish_dt is not None:
-                                    subagent_span.set_finish_time(subagent_finish_dt)
+                                    _set_finish_time_safe(subagent_span, subagent_finish_dt)
                                     subagent_tags["real_start_ms"] = _ts_ms(subagent_start_dt)
                                     subagent_tags["real_end_ms"] = _ts_ms(subagent_finish_dt)
                                     subagent_tags["latency_ms"] = _ts_ms(subagent_finish_dt) - _ts_ms(subagent_start_dt)
@@ -1177,7 +1220,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                                 "agent_name": nickname,
                                             }
                                             if sa_turn_start_dt is not None and sa_turn_finish_dt is not None:
-                                                sa_turn_span.set_finish_time(sa_turn_finish_dt)
+                                                _set_finish_time_safe(sa_turn_span, sa_turn_finish_dt)
                                                 sa_turn_tags["real_start_ms"] = _ts_ms(sa_turn_start_dt)
                                                 sa_turn_tags["real_end_ms"] = _ts_ms(sa_turn_finish_dt)
                                                 sa_turn_tags["latency_ms"] = _ts_ms(sa_turn_finish_dt) - _ts_ms(sa_turn_start_dt)
@@ -1196,7 +1239,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                                     sa_model_span.set_model_name(sa_model)
                                                     sa_model_tags = {"agent_name": nickname}
                                                     if sa_model_start_dt is not None and sa_model_finish_dt is not None:
-                                                        sa_model_span.set_finish_time(sa_model_finish_dt)
+                                                        _set_finish_time_safe(sa_model_span, sa_model_finish_dt)
                                                         sa_model_tags["real_start_ms"] = _ts_ms(sa_model_start_dt)
                                                         sa_model_tags["real_end_ms"] = _ts_ms(sa_model_finish_dt)
                                                         sa_model_tags["latency_ms"] = _ts_ms(sa_model_finish_dt) - _ts_ms(sa_model_start_dt)
@@ -1260,7 +1303,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                                         "agent_name": nickname,
                                                     }
                                                     if sa_tool_start_dt is not None and sa_tool_finish_dt is not None:
-                                                        sa_tool_span.set_finish_time(sa_tool_finish_dt)
+                                                        _set_finish_time_safe(sa_tool_span, sa_tool_finish_dt)
                                                         sa_tool_tags["real_start_ms"] = _ts_ms(sa_tool_start_dt)
                                                         sa_tool_tags["real_end_ms"] = _ts_ms(sa_tool_finish_dt)
                                                         sa_tool_tags["latency_ms"] = _ts_ms(sa_tool_finish_dt) - _ts_ms(sa_tool_start_dt)

package/scripts/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cozeloop/openclaw-cozeloop-trace",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "OpenClaw Plugin for reporting traces to CozeLoop via OpenTelemetry",
   "type": "module",
   "main": "dist/index.js",