coze_lab 0.1.10 → 0.1.12

package/package.json

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

package/scripts/claude-code/cozeloop_hook.py

@@ -331,10 +331,21 @@ def is_tool_result_message(msg: Dict[str, Any]) -> bool:
     )
 
 def extract_tool_result_from_message(msg: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """Extract tool_result items from a user message."""
+    """Extract tool_result items from a user message.
+
+    把外层 user 消息的 timestamp 附到每个 tool_result item 上（_result_ts），
+    用作 tool span 的真实完成时间——否则同一 step 内所有 tool 时间会挤成一样。
+    """
     content = msg.get("message", {}).get("content", [])
+    result_ts = msg.get("timestamp")
     if isinstance(content, list):
-        return [item for item in content if isinstance(item, dict) and item.get("type") == "tool_result"]
+        out = []
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "tool_result":
+                if result_ts and "_result_ts" not in item:
+                    item["_result_ts"] = result_ts
+                out.append(item)
+        return out
     return []
 
 
@@ -450,6 +461,16 @@ def _parse_ts(msg):
         return None
 
 
+def _parse_ts_str(ts):
+    """ISO8601 字符串 → datetime（带时区）。失败返回 None。"""
+    if not ts or not isinstance(ts, str):
+        return None
+    try:
+        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
 def _ts_ms(dt):
     """datetime → 毫秒时间戳（int）；None → None。"""
     return int(dt.timestamp() * 1000) if dt is not None else None
@@ -839,6 +860,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)
                 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)
@@ -897,6 +919,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)
                             _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)
@@ -930,6 +953,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)
                                     model_span.set_tags({
                                         "real_start_ms": _ts_ms(step_start_dt),
                                         "real_end_ms": _ts_ms(step_end_dt),
@@ -1028,13 +1052,30 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                 span_type = "agent" if is_agent else "tool"
                                 span_name = f"agent_{tool_name}" if is_agent else f"tool_{tool_name}"
 
+                                # tool 真实时间：start=模型发起调用（step_start_dt），
+                                # end=该 tool 对应 tool_result 的 timestamp（工具完成时刻）。
+                                # 不同 tool 的 result 时间不同，避免所有 tool span 时间挤成一样。
+                                tool_id = tool_call.get("id")
+                                tool_end_dt = None
+                                for result in step.get("tool_results", []):
+                                    if result.get("tool_use_id") == tool_id:
+                                        tool_end_dt = _parse_ts_str(result.get("_result_ts"))
+                                        break
+
                                 with client.start_span(name=span_name, span_type=span_type, start_time=step_start_dt) as tool_span:
                                     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)
                                     tags = {
                                         "tool_name": tool_name,
                                         "tool_call_id": tool_call.get("id"),
                                         "step_index": j,
                                     }
+                                    if step_start_dt is not None and tool_end_dt is not None:
+                                        tags["real_start_ms"] = _ts_ms(step_start_dt)
+                                        tags["real_end_ms"] = _ts_ms(tool_end_dt)
+                                        tags["latency_ms"] = _ts_ms(tool_end_dt) - _ts_ms(step_start_dt)
                                     if is_agent:
                                         tags["agent_name"] = agent_id
                                     tool_span.set_tags(tags)
@@ -1043,7 +1084,6 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                     )
 
                                     # Find matching tool result
-                                    tool_id = tool_call.get("id")
                                     for result in step.get("tool_results", []):
                                         if result.get("tool_use_id") == tool_id:
                                             result_content = result.get("content", "")
@@ -1345,14 +1385,16 @@ def main():
     # Group messages into turns and send to CozeLoop — only if coze-context present.
     turns = group_messages_into_turns(new_messages)
     if turns:
-        has_coze_ctx = any(
-            coze_context_tags(
+        # coze-context 只出现在首条用户消息里（cozelab 注入的 agent 才有）。增量 hook 触发时，
+        # 新消息往往全是工具调用/结果（不带 coze-context），故必须连同历史 turns 一起判断——
+        # 只要整个会话出现过 coze-context，就说明是被注入的 agent，后续增量都应上报。
+        def _turn_has_ctx(turn):
+            return bool(coze_context_tags(
                 (turn.get("user_message", {}).get("message", {}) or {}).get("content")
-            )
-            for turn in turns
-        )
+            ))
+        has_coze_ctx = any(_turn_has_ctx(t) for t in turns) or any(_turn_has_ctx(t) for t in history_turns)
         if not has_coze_ctx:
-            debug_log("No coze-context found in any turn, skipping upload.")
+            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)