coze_lab 0.1.9 → 0.1.11

package/index.js

@@ -4294,12 +4294,18 @@ const AGENT_CONFIG = {
   },
 };
 
-function detectAgent(agent) {
+function detectAgent(agent, cloud) {
   const cfg = AGENT_CONFIG[agent];
   // Check binary exists
   try {
     execSync(`which ${cfg.binary}`, { stdio: 'pipe' });
   } catch {
+    // 云端 sandbox 里 agent 由 coze-bridge 托管运行，binary 不一定在 PATH。
+    // 配置 hook 不依赖 binary 可执行，所以云端只 warn 不退出。
+    if (cloud) {
+      warn(`${agent} binary 不在 PATH（云端托管，跳过检测）`);
+      return 'cloud';
+    }
     errorBox([
       `ERROR: ${agent} is not installed on this machine`,
       '',
@@ -5197,7 +5203,7 @@ async function main() {
 
   // Step 2: Detect agent binary
   info('Step 2/5: Detecting agent...');
-  const version = detectAgent(agent);
+  const version = detectAgent(agent, args.cloud);
   console.log('');
 
   // Step 3: Environment checks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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", "")