coze_lab 0.1.26 → 0.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Configure local AI agents (Claude Code, Codex, OpenClaw) to report traces to CozeLoop",
   "keywords": [
     "cozeloop",
@@ -14,6 +14,9 @@
   "bin": {
     "coze_lab": "index.js"
   },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
   "files": [
     "index.js",
     "scripts/claude-code/cozeloop_hook.py",

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():
@@ -170,7 +195,7 @@ def _extract_logid(msg: str) -> str:
     return "".join(logid)
 
 
-def _make_finish_event_processor():
+def _make_finish_event_processor(upload_events: Optional[List[str]] = None):
     """Return a trace_finish_event_processor that surfaces failures + logid.
 
     The CozeLoop SDK calls this for each flush event; on failure we print the
@@ -182,6 +207,8 @@ def _make_finish_event_processor():
             if not getattr(info, "is_event_fail", False):
                 return
             detail = getattr(info, "detail_msg", "") or ""
+            if upload_events is not None:
+                upload_events.append(detail or "trace export failed")
             logid = _extract_logid(detail)
             if logid:
                 print(f"[CozeLoop] 上报失败 logid={logid} (可用 bytedcli log get-logid-log {logid} 排查)", file=sys.stderr)
@@ -229,7 +256,11 @@ def _refresh_token(refresh_token: str) -> Optional[str]:
         req = urllib.request.Request(
             f"{_COZE_API}/api/permission/oauth2/token",
             data=payload,
-            headers={"Content-Type": "application/json"},
+            headers={
+                "Content-Type": "application/json",
+                "x-tt-env": "ppe_cozelab",
+                "x-use-ppe": "1",
+            },
         )
         with urllib.request.urlopen(req, timeout=10) as resp:
             data = json.loads(resp.read())
@@ -267,28 +298,48 @@ def get_api_base_url() -> str:
         os.environ.get("COZELOOP_API_BASE_URL", "")
     )
 
+def _token_from_credentials() -> Optional[str]:
+    creds = _load_credentials()
+    if not creds:
+        return None
+    expires_at_sec = creds.get("expires_at", 0) / 1000
+    remaining = expires_at_sec - time.time()
+    if remaining > _REFRESH_THRESHOLD:
+        debug_log(f"Cached token valid, expires in {int(remaining)}s.")
+        return creds.get("access_token")
+    if creds.get("refresh_token"):
+        debug_log(f"Token expiring in {int(remaining)}s, refreshing...")
+        new_token = _refresh_token(creds["refresh_token"])
+        if new_token:
+            return new_token
+        debug_log("Refresh failed.")
+    return None
+
+
 def get_fresh_token() -> Optional[str]:
-    """Return a valid access token, refreshing if needed. Falls back to env var."""
+    """Return a valid access token, refreshing if needed."""
     env_token = os.environ.get("COZELOOP_API_TOKEN")
     env_coze_token = os.environ.get("COZE_API_TOKEN")
+    is_cloud = os.environ.get("COZELAB_ONBOARD_CLOUD", "").lower() in ("1", "true", "yes")
+    if is_cloud:
+        return env_token or env_coze_token or _token_from_credentials()
+
+    # Local onboard used to write a short-lived access token into settings.local.json.
+    # If credentials exist but cannot be refreshed, do not fall back to that stale
+    # env token; failing closed keeps state from advancing on a known-bad token.
+    creds = _load_credentials()
+    if creds:
+        return _token_from_credentials()
+    if env_token and not env_coze_token:
+        token = _token_from_credentials()
+        if token:
+            return token
+        return env_token
     if env_token:
         return env_token
     if env_coze_token:
         return env_coze_token
-    creds = _load_credentials()
-    if creds:
-        expires_at_sec = creds.get("expires_at", 0) / 1000
-        remaining = expires_at_sec - time.time()
-        if remaining > _REFRESH_THRESHOLD:
-            debug_log(f"Cached token valid, expires in {int(remaining)}s.")
-            return creds["access_token"]
-        if creds.get("refresh_token"):
-            debug_log(f"Token expiring in {int(remaining)}s, refreshing...")
-            new_token = _refresh_token(creds["refresh_token"])
-            if new_token:
-                return new_token
-            debug_log("Refresh failed, falling back to env var.")
-    return None
+    return _token_from_credentials()
 
 # -------------------------------------------------------------------------
 
@@ -539,6 +590,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).
 
@@ -889,10 +957,11 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
     creds = _load_credentials()
     workspace_id = (creds or {}).get("workspace_id") or os.environ.get("COZELOOP_WORKSPACE_ID", "") or _DEFAULT_WORKSPACE_ID
     os.environ["COZELOOP_WORKSPACE_ID"] = workspace_id
+    upload_events: List[str] = []
     client_kwargs = {
         "ultra_large_report": True,
         "upload_timeout": 120,
-        "trace_finish_event_processor": _make_finish_event_processor(),
+        "trace_finish_event_processor": _make_finish_event_processor(upload_events),
     }
     if workspace_id:
         client_kwargs["workspace_id"] = workspace_id
@@ -926,7 +995,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 +1054,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 +1088,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 +1201,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"),
@@ -1349,11 +1418,18 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
     except Exception as e:
         print(f"[CozeLoop] 上报失败 ✗ {e}", file=sys.stderr)
         debug_log(f"An error occurred while sending traces to CozeLoop: {e}")
+        return None
     finally:
         # Crucial: close the client to ensure all buffered traces are sent.
         client.close()
         debug_log("CozeLoop client closed.")
 
+    if upload_events:
+        debug_log(f"Upload failed, state not advanced. Last failure: {upload_events[-1][:500]}")
+        return None
+
+    return True
+
 
 # --- Hook Input ---
 
@@ -1463,7 +1539,10 @@ def main():
             debug_log("No coze-context found in any turn (incl. history), skipping upload.")
             return
         print(f"[CozeLoop] 开始上报: session={session_id}, turns={len(turns)}", file=sys.stderr)
-        send_turns_to_cozeloop(turns, session_id, history_turns)
+        uploaded = send_turns_to_cozeloop(turns, session_id, history_turns)
+        if uploaded is None:
+            debug_log("Send failed, state not advanced.")
+            return
 
         # Update state with the new last processed line number
         last_line_in_batch = max(msg.get("_line_number", 0) for msg in new_messages)

package/scripts/codex/cozeloop_hook.py

@@ -137,7 +137,7 @@ def _extract_logid(msg: str) -> str:
     return "".join(logid)
 
 
-def _make_finish_event_processor():
+def _make_finish_event_processor(upload_events: Optional[List[str]] = None):
     """Return a trace_finish_event_processor that surfaces failures + logid.
 
     The CozeLoop SDK calls this for each flush event; on failure we print the
@@ -150,6 +150,8 @@ def _make_finish_event_processor():
                 hook_log("upload success")
                 return
             detail = getattr(info, "detail_msg", "") or ""
+            if upload_events is not None:
+                upload_events.append(detail or "trace export failed")
             logid = _extract_logid(detail)
             if logid:
                 hook_log(f"upload failed logid={logid} detail={detail[:500]}")
@@ -191,15 +193,21 @@ def _refresh_token(refresh_tok: str):
         req = urllib.request.Request(
             f"{_COZE_API}/api/permission/oauth2/token",
             data=payload,
-            headers={"Content-Type": "application/json"},
+            headers={
+                "Content-Type": "application/json",
+                "x-tt-env": "ppe_cozelab",
+                "x-use-ppe": "1",
+            },
         )
         with urllib.request.urlopen(req, timeout=10) as resp:
             data = json.loads(resp.read())
         if data.get("access_token"):
+            existing = _load_credentials() or {}
             creds = {
                 "access_token": data["access_token"],
                 "refresh_token": data.get("refresh_token", refresh_tok),
-                "expires_at": data.get("expires_in", 0) * 1000  # unix timestamp in seconds
+                "expires_at": data.get("expires_in", 0) * 1000,  # unix timestamp in seconds
+                "workspace_id": existing.get("workspace_id", ""),
             }
             _save_credentials(creds)
             return creds["access_token"]
@@ -229,39 +237,84 @@ def get_api_base_url() -> str:
     )
 
 
+def _token_from_credentials():
+    creds = _load_credentials()
+    if not creds:
+        return None
+    remaining = creds.get("expires_at", 0) / 1000 - time.time()
+    if remaining > _REFRESH_THRESHOLD:
+        return creds.get("access_token")
+    if creds.get("refresh_token"):
+        new_token = _refresh_token(creds["refresh_token"])
+        if new_token:
+            return new_token
+    return None
+
+
 def get_fresh_token():
     env_token = os.environ.get("COZELOOP_API_TOKEN")
     env_coze_token = os.environ.get("COZE_API_TOKEN")
+    is_cloud = os.environ.get("COZELAB_ONBOARD_CLOUD", "").lower() in ("1", "true", "yes")
+    if is_cloud:
+        return env_token or env_coze_token or _token_from_credentials()
+
+    # Local onboard used to write a short-lived access token into cozeloop.env.
+    # If credentials exist but cannot be refreshed, do not fall back to that stale
+    # env token; failing closed keeps state from advancing on a known-bad token.
+    creds = _load_credentials()
+    if creds:
+        return _token_from_credentials()
+    if env_token and not env_coze_token:
+        token = _token_from_credentials()
+        if token:
+            return token
+        return env_token
     if env_token:
         return env_token
     if env_coze_token:
         return env_coze_token
-    creds = _load_credentials()
-    if creds:
-        remaining = creds.get("expires_at", 0) / 1000 - time.time()
-        if remaining > _REFRESH_THRESHOLD:
-            return creds["access_token"]
-        if creds.get("refresh_token"):
-            new_token = _refresh_token(creds["refresh_token"])
-            if new_token:
-                return new_token
-    return None
+    return _token_from_credentials()
 # -------------------------------------------------------------------------
 
 # --- 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 +333,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 +694,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:
@@ -923,10 +994,11 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
     workspace_id = (creds or {}).get("workspace_id") or os.environ.get("COZELOOP_WORKSPACE_ID", "") or _DEFAULT_WORKSPACE_ID
     os.environ["COZELOOP_WORKSPACE_ID"] = workspace_id
     hook_log(f"workspace_id={workspace_id}")
+    upload_events: List[str] = []
     client_kwargs = {
         "ultra_large_report": True,
         "upload_timeout": 120,
-        "trace_finish_event_processor": _make_finish_event_processor(),
+        "trace_finish_event_processor": _make_finish_event_processor(upload_events),
     }
     api_base_url = get_api_base_url()
     if api_base_url:
@@ -955,7 +1027,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 +1080,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 +1098,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 +1186,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 +1220,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 +1249,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 +1268,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 +1332,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)
@@ -1309,6 +1381,10 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
         hook_log("client closed")
         debug_log("CozeLoop client closed.")
 
+    if upload_events:
+        hook_log(f"upload failed state not advanced failures={len(upload_events)} detail={upload_events[-1][:500]}")
+        return None
+
     return ctx
 
 

package/scripts/openclaw/dist/cozeloop-exporter.js

@@ -44,10 +44,12 @@ async function _refreshToken(refreshTok) {
                 try {
                     const d = JSON.parse(buf);
                     if (d.access_token) {
+                        const existing = _loadCreds() ?? {};
                         const creds = {
                             access_token: d.access_token,
                             refresh_token: d.refresh_token ?? refreshTok,
                             expires_at: (d.expires_in ?? 0) * 1000,  // unix timestamp in seconds
+                            workspace_id: existing.workspace_id ?? "",
                         };
                         _saveCreds(creds);
                         resolve(creds.access_token);
@@ -62,7 +64,8 @@ async function _refreshToken(refreshTok) {
     });
 }
 
-async function getRefreshedToken(currentAuthorization) {
+async function getRefreshedToken(currentAuthorization, opts = {}) {
+    if (opts.disableLocalCredentials) return currentAuthorization;
     const creds = _loadCreds();
     if (!creds) return currentAuthorization; // no creds file, keep as-is
     const remaining = (creds.expires_at ?? 0) - Date.now();
@@ -71,7 +74,7 @@ async function getRefreshedToken(currentAuthorization) {
         const newToken = await _refreshToken(creds.refresh_token);
         if (newToken) return `Bearer ${newToken}`;
     }
-    return currentAuthorization; // fallback
+    return null;
 }
 // ─────────────────────────────────────────────────────────────────────────
 
@@ -131,7 +134,9 @@ export class CozeloopExporter {
         return attrs;
     }
     async refreshAuthIfNeeded() {
-        const fresh = await getRefreshedToken(this.config.authorization);
+        const fresh = await getRefreshedToken(this.config.authorization, {
+            disableLocalCredentials: this.config.disableLocalCredentials,
+        });
         if (fresh && fresh !== this.config.authorization) {
             this.api.logger.info("[CozeloopTrace] Token refreshed, re-initializing exporter...");
             this.config.authorization = fresh;
@@ -143,6 +148,9 @@ export class CozeloopExporter {
                 this.provider = null;
                 this.tracer = null;
             }
+        } else if (fresh === null) {
+            this.api.logger.error("[CozeloopTrace] Local credentials exist but token refresh failed; refusing to reuse stale authorization.");
+            this.config.authorization = "";
         }
     }
     async ensureInitialized() {

package/scripts/openclaw/dist/index.js

@@ -513,6 +513,7 @@ const cozeloopTracePlugin = {
             batchSize: pluginConfig.batchSize || 10,
             batchInterval: pluginConfig.batchInterval || 5000,
             enabledHooks: pluginConfig.enabledHooks,
+            disableLocalCredentials: pluginConfig.disableLocalCredentials === true,
         };
         const exporter = new CozeloopExporter(api, config);
         // per-agent trace 放行：traceAgentIds 为 onboard 写入的 allowlist（小写归一）。

package/scripts/openclaw/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cozeloop-trace",
   "name": "OpenClaw CozeLoop Trace",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Report OpenClaw execution traces to CozeLoop via OpenTelemetry",
   "type": "plugin",
   "entry": "./dist/index.js",
@@ -49,6 +49,11 @@
           "type": "string"
         },
         "description": "List of hooks to enable (if not set, all hooks are enabled)"
+      },
+      "disableLocalCredentials": {
+        "type": "boolean",
+        "default": false,
+        "description": "Disable ~/.cozeloop credentials refresh and use configured authorization only"
       }
     }
   }

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