coze_lab 0.1.25 → 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.25",
+  "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,71 @@ 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:
+        if value is not None and (result is None or value > result):
+            result = value
+    return result
+
+
+def _parse_ts_value(value):
+    return _parse_ts({"_ts": value}) if value else None
+
+
+def _turn_timestamps(turn):
+    values = []
+    for item in [turn.get("user_message"), *turn.get("assistant_messages", [])]:
+        dt = _parse_ts(item)
+        if dt:
+            values.append(dt)
+    for item in [*turn.get("tool_calls", []), *turn.get("tool_results", [])]:
+        dt = _parse_ts(item)
+        if dt:
+            values.append(dt)
+    for sc in turn.get("subagent_calls", []):
+        for key in ("_start_ts", "_end_ts"):
+            dt = _parse_ts_value(sc.get(key))
+            if dt:
+                values.append(dt)
+    return values
+
+
+def _turn_bounds(turn):
+    values = _turn_timestamps(turn)
+    if not values:
+        return None, None
+    return min(values), max(values)
+
+
+def _assistant_bounds(turn):
+    values = []
+    for item in turn.get("assistant_messages", []):
+        dt = _parse_ts(item)
+        if dt:
+            values.append(dt)
+    if not values:
+        return None, None
+    return min(values), max(values)
+
+
 def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Group raw JSONL entries into conversation turns.
 
@@ -749,6 +840,8 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                         "message": args.get("message", ""),
                         "model": args.get("model"),
                         "result": None,
+                        "_start_ts": payload.get("_ts"),
+                        "_end_ts": None,
                     }
                     current_turn["subagent_calls"].append(subagent_call)
                     pending_calls[call_id] = {"kind": "spawn", "subagent_call": subagent_call}
@@ -756,14 +849,16 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                     pending_calls[call_id] = {
                         "kind": "wait",
                         "ids": args.get("ids", []),
+                        "_start_ts": payload.get("_ts"),
                     }
                 else:
                     current_turn["tool_calls"].append({
                         "call_id": call_id,
                         "name": name,
                         "input": args,
+                        "_ts": payload.get("_ts"),
                     })
-                    pending_calls[call_id] = {"kind": "tool"}
+                    pending_calls[call_id] = {"kind": "tool", "_start_ts": payload.get("_ts")}
 
             elif item_type == "function_call_output":
                 if current_turn is None:
@@ -783,6 +878,7 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                             subagent_call["nickname"] = out.get("nickname")
                         except (json.JSONDecodeError, TypeError, AttributeError):
                             pass
+                        subagent_call["_end_ts"] = payload.get("_ts")
 
                 elif kind == "wait":
                     try:
@@ -795,6 +891,7 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                             for sc in current_turn["subagent_calls"]:
                                 if sc.get("agent_id") == agent_id and sc.get("result") is None:
                                     sc["result"] = result_text
+                                    sc["_end_ts"] = payload.get("_ts")
                                     break
                     except (json.JSONDecodeError, TypeError, AttributeError):
                         pass
@@ -803,6 +900,7 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                     current_turn["tool_results"].append({
                         "call_id": call_id,
                         "output": raw_output,
+                        "_ts": payload.get("_ts"),
                     })
 
     if current_turn is not None:
@@ -888,13 +986,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
         # 整体时间范围：所有 user/assistant payload 的真实 timestamp 极值
         _all_ts = []
         for _t in turns:
-            _u = _parse_ts(_t.get("user_message"))
-            if _u:
-                _all_ts.append(_u)
-            for _a in _t.get("assistant_messages", []):
-                _ad = _parse_ts(_a)
-                if _ad:
-                    _all_ts.append(_ad)
+            _all_ts.extend(_turn_timestamps(_t))
         root_start_dt = min(_all_ts) if _all_ts else None
         root_end_dt = max(_all_ts) if _all_ts else None
 
@@ -906,6 +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:
+                _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)
@@ -947,14 +1040,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
             for i, turn in enumerate(turns):
                 try:
                     # turn 真实时间：start=user payload 时间；end=最后一条 assistant payload 时间
-                    turn_start_dt = _parse_ts(turn.get("user_message"))
-                    turn_end_dt = None
-                    for _a in turn.get("assistant_messages", []):
-                        _ad = _parse_ts(_a)
-                        if _ad:
-                            turn_end_dt = _ad
-                    if turn_start_dt is None:
-                        turn_start_dt = turn_end_dt
+                    turn_start_dt, turn_end_dt = _turn_bounds(turn)
 
                     with client.start_span(name=f"turn_{i}", span_type="main", start_time=turn_start_dt) as turn_span:
                         turn_span.set_runtime(Runtime(library="codex-cli"))
@@ -965,6 +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:
+                            _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)
@@ -973,21 +1060,20 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                         # --- Model span for assistant response ---
                         if turn.get("assistant_messages"):
                             # model span start：第一条 assistant payload 时间，回退到 turn 起点
-                            _model_start_dt = None
-                            for _a in turn.get("assistant_messages", []):
-                                _model_start_dt = _parse_ts(_a)
-                                if _model_start_dt:
-                                    break
+                            _model_start_dt, _model_end_dt = _assistant_bounds(turn)
                             if _model_start_dt is None:
                                 _model_start_dt = turn_start_dt
+                            if _model_end_dt is None:
+                                _model_end_dt = turn_end_dt
                             with client.start_span(name="assistant_response", span_type="model", start_time=_model_start_dt) as model_span:
                                 model_span.set_runtime(Runtime(library="codex-cli"))
                                 model_span.set_model_name(model_name)
-                                if _model_start_dt is not None and turn_end_dt is not None:
+                                if _model_start_dt is not None and _model_end_dt is not None:
+                                    _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(turn_end_dt),
-                                        "latency_ms": _ts_ms(turn_end_dt) - _ts_ms(_model_start_dt),
+                                        "real_end_ms": _ts_ms(_model_end_dt),
+                                        "latency_ms": _ts_ms(_model_end_dt) - _ts_ms(_model_start_dt),
                                     })
 
                                 # Build input messages: history + current turn input
@@ -1056,17 +1142,30 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                         # --- Tool call spans ---
                         for tool_call in turn.get("tool_calls", []):
                             tool_name = tool_call.get("name", "unknown")
-                            with client.start_span(name=f"tool_{tool_name}", span_type="tool", start_time=turn_start_dt) as tool_span:
+                            tool_start_dt = _parse_ts(tool_call) or turn_start_dt
+                            tool_end_dt = None
+                            call_id = tool_call.get("call_id")
+                            for result in turn.get("tool_results", []):
+                                if result.get("call_id") == call_id:
+                                    tool_end_dt = _parse_ts(result)
+                                    break
+                            tool_finish_dt = _max_dt(tool_end_dt, tool_start_dt)
+                            with client.start_span(name=f"tool_{tool_name}", span_type="tool", start_time=tool_start_dt) as tool_span:
                                 tool_span.set_runtime(Runtime(library="codex-cli"))
-                                tool_span.set_tags({
+                                tool_tags = {
                                     "tool_name": tool_name,
-                                    "call_id": tool_call.get("call_id"),
-                                })
+                                    "call_id": call_id,
+                                }
+                                if tool_start_dt is not None and tool_finish_dt is not None:
+                                    _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)
+                                tool_span.set_tags(tool_tags)
                                 tool_span.set_input(
                                     json.dumps(tool_call.get("input", {}), ensure_ascii=False)[:2000]
                                 )
                                 # Find matching tool result
-                                call_id = tool_call.get("call_id")
                                 for result in turn.get("tool_results", []):
                                     if result.get("call_id") == call_id:
                                         output = result.get("output", "")
@@ -1079,15 +1178,24 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                         for sc in turn.get("subagent_calls", []):
                             agent_id = sc.get("agent_id") or "unknown"
                             nickname = sc.get("nickname") or agent_id
+                            subagent_start_dt = _parse_ts_value(sc.get("_start_ts")) or turn_start_dt
+                            subagent_end_dt = _parse_ts_value(sc.get("_end_ts")) or turn_end_dt
+                            subagent_finish_dt = _max_dt(subagent_end_dt, subagent_start_dt)
 
-                            with client.start_span(name=f"subagent_{nickname}", span_type="agent", start_time=turn_start_dt) as subagent_span:
+                            with client.start_span(name=f"subagent_{nickname}", span_type="agent", start_time=subagent_start_dt) as subagent_span:
                                 subagent_span.set_runtime(Runtime(library="codex-cli"))
-                                subagent_span.set_tags({
+                                subagent_tags = {
                                     "agent_id": agent_id,
                                     "agent_nickname": nickname,
                                     "agent_role": sc.get("role") or "",
                                     "agent_model": sc.get("model") or "",
-                                })
+                                }
+                                if subagent_start_dt is not None and subagent_finish_dt is not None:
+                                    _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)
+                                subagent_span.set_tags(subagent_tags)
                                 subagent_span.set_input(sc.get("message", "")[:2000])
 
                                 # Load and include saved subagent turn data
@@ -1097,20 +1205,45 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                     sa_model = sa_data.get("model_name", "codex")
 
                                     for si, sa_turn in enumerate(sa_turns):
-                                        with client.start_span(name=f"turn_{si}", span_type="main") as sa_turn_span:
+                                        sa_turn_start_dt, sa_turn_end_dt = _turn_bounds(sa_turn)
+                                        if sa_turn_start_dt is None:
+                                            sa_turn_start_dt = subagent_start_dt
+                                        if sa_turn_end_dt is None:
+                                            sa_turn_end_dt = sa_turn_start_dt
+                                        sa_turn_finish_dt = _max_dt(sa_turn_end_dt, sa_turn_start_dt)
+
+                                        with client.start_span(name=f"turn_{si}", span_type="main", start_time=sa_turn_start_dt) as sa_turn_span:
                                             sa_turn_span.set_runtime(Runtime(library="codex-cli"))
-                                            sa_turn_span.set_tags({
+                                            sa_turn_tags = {
                                                 "turn_index": si,
                                                 "turn_id": sa_turn.get("turn_id", ""),
                                                 "agent_name": nickname,
-                                            })
+                                            }
+                                            if sa_turn_start_dt is not None and sa_turn_finish_dt is not None:
+                                                _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)
+                                            sa_turn_span.set_tags(sa_turn_tags)
 
                                             # Subagent model span
                                             if sa_turn.get("assistant_messages"):
-                                                with client.start_span(name="assistant_response", span_type="model") as sa_model_span:
+                                                sa_model_start_dt, sa_model_end_dt = _assistant_bounds(sa_turn)
+                                                if sa_model_start_dt is None:
+                                                    sa_model_start_dt = sa_turn_start_dt
+                                                if sa_model_end_dt is None:
+                                                    sa_model_end_dt = sa_turn_end_dt
+                                                sa_model_finish_dt = _max_dt(sa_model_end_dt, sa_model_start_dt)
+                                                with client.start_span(name="assistant_response", span_type="model", start_time=sa_model_start_dt) as sa_model_span:
                                                     sa_model_span.set_runtime(Runtime(library="codex-cli"))
                                                     sa_model_span.set_model_name(sa_model)
-                                                    sa_model_span.set_tags({"agent_name": nickname})
+                                                    sa_model_tags = {"agent_name": nickname}
+                                                    if sa_model_start_dt is not None and sa_model_finish_dt is not None:
+                                                        _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)
+                                                    sa_model_span.set_tags(sa_model_tags)
 
                                                     sa_input = sa_turn.get("input_messages", [])
                                                     if not sa_input:
@@ -1154,17 +1287,30 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                                             # Subagent tool spans
                                             for sa_tc in sa_turn.get("tool_calls", []):
                                                 sa_tool_name = sa_tc.get("name", "unknown")
-                                                with client.start_span(name=f"tool_{sa_tool_name}", span_type="tool") as sa_tool_span:
+                                                sa_tool_start_dt = _parse_ts(sa_tc) or sa_turn_start_dt
+                                                sa_tool_end_dt = None
+                                                sa_cid = sa_tc.get("call_id")
+                                                for sa_r in sa_turn.get("tool_results", []):
+                                                    if sa_r.get("call_id") == sa_cid:
+                                                        sa_tool_end_dt = _parse_ts(sa_r)
+                                                        break
+                                                sa_tool_finish_dt = _max_dt(sa_tool_end_dt, sa_tool_start_dt)
+                                                with client.start_span(name=f"tool_{sa_tool_name}", span_type="tool", start_time=sa_tool_start_dt) as sa_tool_span:
                                                     sa_tool_span.set_runtime(Runtime(library="codex-cli"))
-                                                    sa_tool_span.set_tags({
+                                                    sa_tool_tags = {
                                                         "tool_name": sa_tool_name,
-                                                        "call_id": sa_tc.get("call_id"),
+                                                        "call_id": sa_cid,
                                                         "agent_name": nickname,
-                                                    })
+                                                    }
+                                                    if sa_tool_start_dt is not None and sa_tool_finish_dt is not None:
+                                                        _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)
+                                                    sa_tool_span.set_tags(sa_tool_tags)
                                                     sa_tool_span.set_input(
                                                         json.dumps(sa_tc.get("input", {}), ensure_ascii=False)[:2000]
                                                     )
-                                                    sa_cid = sa_tc.get("call_id")
                                                     for sa_r in sa_turn.get("tool_results", []):
                                                         if sa_r.get("call_id") == sa_cid:
                                                             sa_out = sa_r.get("output", "")

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",