coze_lab 0.1.24 → 0.1.26

package/README.md

@@ -74,6 +74,8 @@ In cloud mode, trace verification and hook uploads prefer
 `COZELOOP_API_TOKEN` and fall back to `COZE_API_TOKEN`. The selfcheck result is
 authoritative: if the token does not have trace ingest permission, onboard still
 writes the hook configuration but reports `verify=fail` with `token_source`.
+For Python SDK uploads, `OTEL_ENDPOINT` is not used as the SDK base URL; set
+`COZELOOP_API_BASE_URL` only when the SDK ingest endpoint should be overridden.
 
 **At hook execution time** (Claude Code / Codex), the Python hook script automatically:
 1. Reads `~/.cozeloop/credentials.json`

package/index.js

@@ -4706,6 +4706,10 @@ function normalizeTraceAgentIds(ids) {
 
 function getCloudCozeloopApiBaseUrl() {
   const raw = process.env.COZELOOP_API_BASE_URL || process.env.OTEL_ENDPOINT || '';
+  return normalizeCozeloopApiBaseUrl(raw);
+}
+
+function normalizeCozeloopApiBaseUrl(raw) {
   const base = raw.trim().replace(/\/+$/, '');
   if (!base) return '';
   if (base.endsWith('/v1/loop/opentelemetry/v1/traces')) {
@@ -4730,6 +4734,14 @@ function getCozeloopApiBaseUrl(cloud) {
   return cloud ? (getCloudCozeloopApiBaseUrl() || COZE_API) : COZE_API;
 }
 
+function getCloudCozeloopSdkApiBaseUrl() {
+  return normalizeCozeloopApiBaseUrl(process.env.COZELOOP_API_BASE_URL || '');
+}
+
+function getCozeloopSdkApiBaseUrl(cloud) {
+  return cloud ? (getCloudCozeloopSdkApiBaseUrl() || COZE_API) : COZE_API;
+}
+
 function getOtelEndpointBase(cloud) {
   return `${getCozeloopApiBaseUrl(cloud).replace(/\/+$/, '')}/v1/loop/opentelemetry`;
 }
@@ -4935,11 +4947,13 @@ function runCommand(input) {
 
 async function verifyTraceReportViaSdk(token, workspaceId, pairCode, pythonCmd, tokenSource) {
   const pair = pairCode || crypto.randomBytes(6).toString('hex');
-  const apiBase = getCozeloopApiBaseUrl(true);
+  const apiBase = getCozeloopSdkApiBaseUrl(true);
   const script = `
 import json
 import os
 import sys
+import urllib.error
+import urllib.request
 
 events = []
 
@@ -4947,6 +4961,51 @@ def finish_event(info):
     if getattr(info, "is_event_fail", False):
         events.append(getattr(info, "detail_msg", "") or "trace export failed")
 
+def extract_logid(text):
+    if not text:
+        return ""
+    marker = "logid="
+    idx = text.find(marker)
+    if idx >= 0:
+        out = []
+        for ch in text[idx + len(marker):]:
+            if ch.isalnum():
+                out.append(ch)
+            else:
+                break
+        return "".join(out)
+    for marker in ('"logid":"', '"log_id":"', '"Logid":"'):
+        idx = text.find(marker)
+        if idx >= 0:
+            rest = text[idx + len(marker):]
+            return rest.split('"', 1)[0]
+    return ""
+
+def http_diag():
+    base = os.environ.get("COZELOOP_API_BASE_URL", "").strip().rstrip("/") or "https://api.coze.cn"
+    url = base + "/v1/loop/traces/ingest"
+    body = json.dumps({"spans": []}).encode()
+    req = urllib.request.Request(
+        url,
+        data=body,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + os.environ.get("COZELOOP_API_TOKEN", ""),
+            "x-tt-env": os.environ.get("x_tt_env", ""),
+            "x-use-ppe": os.environ.get("x_use_ppe", ""),
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            text = resp.read().decode("utf-8", "replace")
+            return {"url": url, "status": resp.status, "logid": resp.headers.get("x-tt-logid", "") or extract_logid(text), "body": text[:300]}
+    except urllib.error.HTTPError as e:
+        text = e.read().decode("utf-8", "replace")
+        return {"url": url, "status": e.code, "logid": e.headers.get("x-tt-logid", "") or extract_logid(text), "body": text[:300]}
+    except Exception as e:
+        return {"url": url, "status": 0, "logid": "", "body": type(e).__name__ + ": " + str(e)}
+
 try:
     import cozeloop
     kwargs = {
@@ -4966,11 +5025,15 @@ try:
     client.flush()
     client.close()
     if events:
-        print(json.dumps({"success": False, "body": "\\n".join(events), "api_base_url": os.environ.get("COZELOOP_API_BASE_URL", ""), "token_source": os.environ.get("COZELOOP_TOKEN_SOURCE", "")}, ensure_ascii=False))
+        diag = http_diag()
+        body = "\\n".join(events) + "\\nhttp_diag=" + json.dumps(diag, ensure_ascii=False)
+        print(json.dumps({"success": False, "body": body, "logid": diag.get("logid", ""), "api_base_url": os.environ.get("COZELOOP_API_BASE_URL", ""), "token_source": os.environ.get("COZELOOP_TOKEN_SOURCE", "")}, ensure_ascii=False))
         sys.exit(1)
-    print(json.dumps({"success": True, "body": "", "api_base_url": os.environ.get("COZELOOP_API_BASE_URL", ""), "token_source": os.environ.get("COZELOOP_TOKEN_SOURCE", "")}, ensure_ascii=False))
+    print(json.dumps({"success": True, "body": "", "logid": "", "api_base_url": os.environ.get("COZELOOP_API_BASE_URL", ""), "token_source": os.environ.get("COZELOOP_TOKEN_SOURCE", "")}, ensure_ascii=False))
 except Exception as e:
-    print(json.dumps({"success": False, "body": str(e), "api_base_url": os.environ.get("COZELOOP_API_BASE_URL", ""), "token_source": os.environ.get("COZELOOP_TOKEN_SOURCE", "")}, ensure_ascii=False))
+    diag = http_diag()
+    body = str(e) + "\\nhttp_diag=" + json.dumps(diag, ensure_ascii=False)
+    print(json.dumps({"success": False, "body": body, "logid": diag.get("logid", ""), "api_base_url": os.environ.get("COZELOOP_API_BASE_URL", ""), "token_source": os.environ.get("COZELOOP_TOKEN_SOURCE", "")}, ensure_ascii=False))
     sys.exit(1)
 `;
   const env = {
@@ -5005,7 +5068,7 @@ except Exception as e:
     const snippet = String(body || '').slice(0, 300);
     if (snippet) console.log(snippet);
   }
-  return { success, status: result.code || 0, body, traceId: '', pairCode: pair, apiBaseUrl: apiBase, tokenSource };
+  return { success, status: result.code || 0, body, traceId: '', pairCode: pair, apiBaseUrl: apiBase, tokenSource, logid: parsed?.logid || '' };
 }
 
 // 真实发一条最小 OTLP trace 到 CozeLoop，验证上报链路是否打通。
@@ -5538,7 +5601,7 @@ async function main() {
   } else if (CLOUD_MODE) {
     // 云端：注入已成功，验证失败不阻断（放行），记录结果供后台弹 warning。
     cloudResult.verify = 'fail';
-    cloudResult.logid = extractLogid(verifyResult.body) || cloudResult.logid;
+    cloudResult.logid = verifyResult.logid || extractLogid(verifyResult.body) || cloudResult.logid;
     cloudResult.message = `trace 上报自检失败 HTTP ${verifyResult.status}: ${(verifyResult.body || '').slice(0, 200)}`;
     warn('trace 上报自检失败，但 hook 配置已写入（云端放行）。');
     console.log('');

package/package.json

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

package/scripts/claude-code/cozeloop_hook.py

@@ -264,7 +264,7 @@ def _normalize_api_base_url(url: str) -> str:
 
 def get_api_base_url() -> str:
     return _normalize_api_base_url(
-        os.environ.get("COZELOOP_API_BASE_URL", "") or os.environ.get("OTEL_ENDPOINT", "")
+        os.environ.get("COZELOOP_API_BASE_URL", "")
     )
 
 def get_fresh_token() -> Optional[str]:

package/scripts/codex/cozeloop_hook.py

@@ -225,7 +225,7 @@ def _normalize_api_base_url(url: str) -> str:
 
 def get_api_base_url() -> str:
     return _normalize_api_base_url(
-        os.environ.get("COZELOOP_API_BASE_URL", "") or os.environ.get("OTEL_ENDPOINT", "")
+        os.environ.get("COZELOOP_API_BASE_URL", "")
     )
 
 
@@ -640,6 +640,54 @@ def _ts_ms(dt):
     return int(dt.timestamp() * 1000) if dt is not None else None
 
 
+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 +797,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 +806,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 +835,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 +848,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 +857,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 +943,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 +955,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)
                 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 +997,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 +1008,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)
                             _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 +1017,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:
+                                    model_span.set_finish_time(_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 +1099,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:
+                                    tool_span.set_finish_time(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 +1135,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:
+                                    subagent_span.set_finish_time(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 +1162,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:
+                                                sa_turn_span.set_finish_time(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:
+                                                        sa_model_span.set_finish_time(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 +1244,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:
+                                                        sa_tool_span.set_finish_time(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", "")