coze_lab 0.1.54 → 0.1.56

package/package.json

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

package/scripts/claude-code/cozeloop_hook.py

@@ -1465,6 +1465,33 @@ def _flatten_completed_steps(turns: List[Dict[str, Any]], is_terminal: bool = Fa
     return completed, len(flat)
 
 
+def _reconstructed_model_bounds(item: Dict[str, Any]):
+    """Return request-ready -> assistant-emitted bounds for one Claude step."""
+    turn = item.get("turn") or {}
+    step = item.get("step") or {}
+    step_index = item.get("step_index", 0)
+    assistant_dt = _parse_ts(step.get("assistant_message"))
+    start_dt = None
+    if step_index > 0:
+        previous_steps = turn.get("steps", [])
+        if step_index <= len(previous_steps) - 1:
+            previous = previous_steps[step_index - 1]
+            result_times = [
+                _parse_ts_str(result.get("_result_ts"))
+                for result in previous.get("tool_results", [])
+            ]
+            result_times = [value for value in result_times if value is not None]
+            if result_times:
+                start_dt = max(result_times)
+            else:
+                start_dt = _parse_ts(previous.get("assistant_message"))
+    if start_dt is None:
+        start_dt = _parse_ts(turn.get("user_message"))
+    if start_dt is None:
+        start_dt = assistant_dt
+    return start_dt, assistant_dt or start_dt
+
+
 def send_steps_realtime(turns, session_id, history_turns, state, coze_tags_override=None, is_terminal=False):
     """实时上报：把新完成的 step 作为 span 挂到稳定 root，结束即 flush。
 
@@ -1569,17 +1596,14 @@ def send_steps_realtime(turns, session_id, history_turns, state, coze_tags_overr
             amo = assistant_msg.get("message", {})
             model_name = amo.get("model", "claude-code")
             gidx = last_global + sent  # 全局 step 序号，用于命名
-            step_start_dt = _parse_ts(assistant_msg)
-            step_end_dt = None
-            for r in step.get("tool_results", []):
-                te = _parse_ts_str(r.get("_result_ts"))
-                if te:
-                    step_end_dt = te
+            step_start_dt, step_end_dt = _reconstructed_model_bounds(item)
+            assistant_dt = _parse_ts(assistant_msg) or step_end_dt
 
             # model_span 挂 root
             mspan = client.start_span(name=f"model_call_{gidx}", span_type="model",
                                       start_time=step_start_dt, child_of=root_ctx)
             mspan.set_runtime(Runtime(library="claude-code"))
+            mspan.set_tags({"timing_source": "reconstructed"})
             try:
                 mspan.set_model_name(model_name)
             except Exception:
@@ -1635,7 +1659,7 @@ def send_steps_realtime(turns, session_id, history_turns, state, coze_tags_overr
                         tool_end_dt = _parse_ts_str(r.get("_result_ts"))
                         break
                 tspan = client.start_span(name=f"tool_{tname}", span_type="tool",
-                                          start_time=step_start_dt, child_of=mspan_ctx)
+                                          start_time=assistant_dt, child_of=mspan_ctx)
                 tspan.set_runtime(Runtime(library="claude-code"))
                 if tool_end_dt is not None:
                     _set_finish_time_safe(tspan, tool_end_dt)

package/scripts/codex/cozeloop_hook.py

@@ -741,13 +741,45 @@ def _assistant_bounds(turn):
     return min(values), max(values)
 
 
-def extract_token_events(entries: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """扫 rollout event_msg/token_count 事件, 与 turn 完全解耦.
-
-    每条事件独立采集, 依赖 _line_number 做全局水位线幂等. 只收 last_token_usage 非空的事件
-    (空的是心跳/占位, 不代表真实模型调用). total_token_usage 一并保留供 tag 上报.
+def extract_model_invocations(turns: List[Dict[str, Any]],
+                              entries: List[Dict[str, Any]],
+                              is_terminal: bool = False) -> List[Dict[str, Any]]:
+    """Group visible model output, tool calls, and usage into model invocations.
+
+    Codex emits one non-empty ``token_count.last_token_usage`` after each model
+    invocation. It is the only reliable boundary shared by tool and no-tool
+    calls, so records since the previous boundary are reported together. The
+    cumulative ``total_token_usage`` is retained as metadata only.
     """
     events: List[Dict[str, Any]] = []
+    tool_results: Dict[str, Dict[str, Any]] = {}
+
+    for turn in turns:
+        for result in turn.get("tool_results", []):
+            call_id = result.get("call_id")
+            if call_id:
+                tool_results[call_id] = result
+        for record in turn.get("model_records", []):
+            events.append({
+                "kind": "record",
+                "line": record.get("_line_number", -1),
+                "timestamp": record.get("_ts"),
+                "record": record,
+                "turn": turn,
+            })
+        for tool_call in turn.get("tool_calls", []):
+            events.append({
+                "kind": "tool",
+                "line": tool_call.get("_line_number", -1),
+                "timestamp": tool_call.get("_ts"),
+                "tool_call": tool_call,
+                "turn": turn,
+            })
+
+    turn_starts = sorted(
+        ((turn.get("start_line", -1), turn) for turn in turns),
+        key=lambda item: item[0],
+    )
     for entry in entries:
         if entry.get("type") != "event_msg":
             continue
@@ -758,13 +790,132 @@ def extract_token_events(entries: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         last_usage = info.get("last_token_usage")
         if not isinstance(last_usage, dict) or not last_usage:
             continue
+        line = entry.get("_line_number", 0)
+        boundary_turn = None
+        for start_line, turn in turn_starts:
+            if start_line > line:
+                break
+            boundary_turn = turn
         events.append({
-            "line": entry.get("_line_number", 0),
+            "kind": "usage",
+            "line": line,
             "timestamp": entry.get("timestamp"),
             "usage": last_usage,
             "total_usage": info.get("total_token_usage") or {},
+            "turn": boundary_turn,
         })
-    return events
+
+    events.sort(key=lambda item: (item.get("line", -1),
+                                  {"record": 0, "tool": 1, "usage": 2}.get(item.get("kind"), 3)))
+    invocations: List[Dict[str, Any]] = []
+    current: Dict[str, Any] = {
+        "content_parts": [],
+        "reasoning_parts": [],
+        "protected": {"source": "", "count": 0, "bytes": 0},
+        "tool_calls": [],
+        "turn": None,
+        "start_timestamp": None,
+        "end_timestamp": None,
+        "line": -1,
+        "usage": {},
+        "total_usage": {},
+    }
+    seen = {"content": set(), "reasoning": set()}
+
+    def request_timestamp(turn: Optional[Dict[str, Any]]) -> Optional[str]:
+        if not turn:
+            return None
+        user_message = turn.get("user_message") or {}
+        return user_message.get("_ts") or turn.get("start_timestamp")
+
+    def append_text(category: str, value: Any):
+        if not isinstance(value, str):
+            return
+        text = value.strip()
+        if not text or text in seen[category]:
+            return
+        seen[category].add(text)
+        current[f"{category}_parts"].append(text)
+
+    def finish_current(boundary_line: int, boundary_ts: Optional[str],
+                       usage: Optional[Dict[str, Any]] = None,
+                       total_usage: Optional[Dict[str, Any]] = None):
+        has_payload = (
+            current["content_parts"] or current["reasoning_parts"]
+            or current["tool_calls"] or current["protected"].get("count")
+            or usage
+        )
+        if not has_payload:
+            return
+        current["line"] = boundary_line
+        if current["end_timestamp"] is None:
+            current["end_timestamp"] = boundary_ts
+            current["timing_source"] = "reconstructed_usage_fallback"
+        else:
+            current["timing_source"] = "reconstructed"
+        current["usage"] = usage or {}
+        current["total_usage"] = total_usage or {}
+        current["content"] = "\n".join(current.pop("content_parts"))
+        current["reasoning"] = "\n".join(current.pop("reasoning_parts"))
+        for tool_call in current["tool_calls"]:
+            tool_call["result"] = tool_results.get(tool_call.get("call_id"))
+        invocations.append(dict(current))
+
+    for event in events:
+        kind = event["kind"]
+        if kind == "usage":
+            if current["turn"] is None:
+                current["turn"] = event.get("turn")
+            if current["start_timestamp"] is None:
+                current["start_timestamp"] = event.get("timestamp")
+            finish_current(event["line"], event.get("timestamp"),
+                           event.get("usage"), event.get("total_usage"))
+            current = {
+                "content_parts": [],
+                "reasoning_parts": [],
+                "protected": {"source": "", "count": 0, "bytes": 0},
+                "tool_calls": [],
+                "turn": None,
+                "start_timestamp": event.get("timestamp"),
+                "start_turn": event.get("turn"),
+                "end_timestamp": None,
+                "line": -1,
+                "usage": {},
+                "total_usage": {},
+            }
+            seen = {"content": set(), "reasoning": set()}
+            continue
+
+        current["turn"] = current["turn"] or event.get("turn")
+        if current.get("start_turn") is not None and current.get("start_turn") is not event.get("turn"):
+            current["start_timestamp"] = None
+            current["start_turn"] = event.get("turn")
+        current["start_timestamp"] = (
+            current["start_timestamp"]
+            or request_timestamp(event.get("turn"))
+            or event.get("timestamp")
+        )
+        current["end_timestamp"] = event.get("timestamp") or current["end_timestamp"]
+        current["line"] = max(current["line"], event.get("line", -1))
+        if kind == "record":
+            record = event["record"]
+            append_text("content", record.get("content"))
+            append_text("reasoning", record.get("reasoning"))
+            protected = record.get("protected") or {}
+            if protected.get("count"):
+                current["protected"]["source"] = protected.get("source", "")
+                current["protected"]["count"] += protected.get("count", 0)
+                current["protected"]["bytes"] += protected.get("bytes", 0)
+        elif kind == "tool":
+            current["tool_calls"].append(dict(event["tool_call"]))
+
+    if is_terminal and (
+        current["content_parts"] or current["reasoning_parts"]
+        or current["tool_calls"] or current["protected"].get("count")
+    ):
+        finish_current(current["line"], current["end_timestamp"])
+
+    return invocations
 
 
 def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -811,6 +962,7 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                     "subagent_calls": [],
                     "token_usage": {},
                     "start_line": entry.get("_line_number", 0),
+                    "start_timestamp": payload.get("_ts"),
                 }
                 pending_calls = {}
             elif msg_type == "task_complete":
@@ -923,6 +1075,7 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
                         "input": args,
                         "custom": item_type == "custom_tool_call",
                         "_ts": payload.get("_ts"),
+                        "_line_number": entry.get("_line_number", -1),
                     })
                     pending_calls[call_id] = {"kind": "tool", "_start_ts": payload.get("_ts")}
 
@@ -1481,14 +1634,15 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
     return ctx
 
 
-# --- 实时 step 级上报（方案 B：每个 tool_call 结束即可见）---------------------
+# --- 实时 model invocation 上报 -------------------------------------------
 #
 # 与 claude-code 同架构：一个会话 = 一条稳定 trace。首次建 root(codex_request)立即 finish 并存
-# to_header() 到 state["rt_root_header"]；之后每次触发把【新完成的 tool_call】(有 result 的)作为
-# tool span 挂到固定 root、当场 flush。codex 的实时单元是 tool_call（turn 内平铺，按 call_id 关联
-# result）。全局水位线 state["rt_last_tool"] 跟踪已发的 tool_call 数。
+# to_header() 到 state["rt_root_header"]；之后按 token_count 边界把模型可见内容、推理、工具调用和
+# last_token_usage 合成 model_call span，工具执行作为其子 span。全局行号水位线
+# state["rt_last_invocation_line"] 保证重复 hook 不重发。
 
-def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_override=None, is_terminal=False, token_events=None):
+def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_override=None,
+                        is_terminal=False, model_invocations=None):
     import cozeloop
     from cozeloop.spec.tracespec import Runtime
     token = get_fresh_token()
@@ -1562,197 +1716,163 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
                 return None
             hook_log(f"[rt] root created trace_id={getattr(root_ctx,'trace_id','?')}")
 
-        # Model-visible records use their own line watermark. They are not
-        # coupled to tool completion because reasoning/commentary can occur in
-        # turns with no tools at all.
-        model_records = []
-        for turn in turns:
-            for record in turn.get("model_records", []):
-                model_records.append((turn, record))
-        model_records.sort(key=lambda item: item[1].get("_line_number", -1))
-        last_model_line = state.get("rt_last_model_line", -1)
-        model_sent = 0
-        max_model_line = last_model_line
-        for turn, record in model_records:
-            line = record.get("_line_number", -1)
-            if line <= last_model_line:
-                continue
-            content = record.get("content", "")
-            reasoning = record.get("reasoning", "")
-            protected = record.get("protected") or {}
-            if not content and not reasoning and not protected:
-                max_model_line = max(max_model_line, line)
-                continue
-            start_dt = _parse_ts_value(record.get("_ts"))
+        # One atomic model span per Codex invocation. Upgrade existing sessions
+        # without replaying events already emitted by the pre-0.1.55 watermarks.
+        legacy_line = max(state.get("rt_last_model_line", -1),
+                          state.get("rt_last_token_line", -1))
+        last_invocation_line = state.get("rt_last_invocation_line", legacy_line)
+        pending_invocations = [
+            invocation for invocation in (model_invocations or [])
+            if invocation.get("line", -1) > last_invocation_line
+        ]
+        if pending_invocations and not is_terminal:
+            since = time.time() - state.get("rt_last_upload_ts", 0)
+            if since < REALTIME_BATCH_INTERVAL:
+                hook_log(
+                    f"[rt] batch throttle {since:.1f}s<{REALTIME_BATCH_INTERVAL}s "
+                    f"defer {len(pending_invocations)} invocation(s)"
+                )
+                pending_invocations = []
+
+        invocation_sent = 0
+        tool_sent = 0
+        model_call_base = state.get(
+            "rt_model_call_count", state.get("rt_last_tool", 0)
+        )
+        for invocation in pending_invocations:
+            line = invocation.get("line", -1)
+            turn = invocation.get("turn") or {}
+            tool_calls = invocation.get("tool_calls") or []
+            model_tool_calls = []
+            for tool_call in tool_calls:
+                model_tool_calls.append(ModelToolCall(
+                    id=tool_call.get("call_id", ""),
+                    type="function",
+                    function=ModelToolCallFunction(
+                        name=tool_call.get("name", ""),
+                        arguments=_json_text(tool_call.get("input", {})),
+                    ),
+                ))
+
+            start_dt = _parse_ts_value(invocation.get("start_timestamp"))
+            end_dt = _parse_ts_value(invocation.get("end_timestamp")) or start_dt
             mspan = client.start_span(
-                name=f"model_content_{line}", span_type="model",
-                start_time=start_dt, child_of=root_ctx,
+                name=f"model_call_{invocation_sent + model_call_base}",
+                span_type="model", start_time=start_dt, child_of=root_ctx,
             )
             mspan.set_runtime(Runtime(library="codex-cli"))
             try:
                 mspan.set_model_name(model_name)
             except Exception:
                 pass
-            if turn.get("user_message_text"):
-                mspan.set_input(ModelInput(
-                    messages=[_make_model_message("user", turn["user_message_text"])],
-                    tools=[],
-                    tool_choice=ModelToolChoice(type="", function=None),
+            if start_dt is not None and end_dt is not None:
+                _set_finish_time_safe(mspan, _max_dt(start_dt, end_dt))
+
+            input_messages = []
+            for message in turn.get("input_messages", []):
+                input_messages.append(_make_model_message(
+                    message.get("role", "user"), message.get("content", "")
                 ))
-            choice = ModelChoice(
-                finish_reason="stop",
+            if not input_messages and turn.get("user_message_text"):
+                input_messages.append(_make_model_message("user", turn["user_message_text"]))
+            mspan.set_input(ModelInput(
+                messages=input_messages,
+                tools=[],
+                tool_choice=ModelToolChoice(type="", function=None),
+            ))
+            mspan.set_output(ModelOutput(choices=[ModelChoice(
+                finish_reason="tool_calls" if model_tool_calls else "stop",
                 index=0,
                 message=ModelMessage(
                     role="assistant",
-                    content=content,
-                    reasoning_content=reasoning,
+                    content=invocation.get("content", ""),
+                    reasoning_content=invocation.get("reasoning", ""),
                     parts=[],
                     name="",
-                    tool_calls=[],
+                    tool_calls=model_tool_calls,
                     tool_call_id="",
                     metadata={},
                 ),
-            )
-            mspan.set_output(ModelOutput(choices=[choice]))
+            )]))
+
+            usage = invocation.get("usage") or {}
+            in_tk = _usage_int(usage, "input_tokens")
+            out_tk = _usage_int(usage, "output_tokens")
+            if in_tk > 0:
+                try:
+                    mspan.set_input_tokens(in_tk)
+                except Exception:
+                    pass
+            if out_tk > 0:
+                try:
+                    mspan.set_output_tokens(out_tk)
+                except Exception:
+                    pass
+
             tags = {
-                "model_record_line": line,
-                "model_record_source": record.get("source", "unknown"),
+                "invocation_boundary_line": line,
+                "token_source": "codex_token_count" if usage else "unavailable",
+                "timing_source": invocation.get("timing_source", "reconstructed"),
+                "cached_input_tokens": _usage_int(usage, "cached_input_tokens"),
+                "reasoning_output_tokens": _usage_int(usage, "reasoning_output_tokens"),
+                "total_tokens": _usage_int(usage, "total_tokens"),
             }
-            if protected:
+            total = invocation.get("total_usage") or {}
+            if total:
+                tags.update({
+                    "total_input_tokens": _usage_int(total, "input_tokens"),
+                    "total_output_tokens": _usage_int(total, "output_tokens"),
+                    "total_cached_input_tokens": _usage_int(total, "cached_input_tokens"),
+                    "total_reasoning_output_tokens": _usage_int(total, "reasoning_output_tokens"),
+                    "total_all_tokens": _usage_int(total, "total_tokens"),
+                })
+            protected = invocation.get("protected") or {}
+            if protected.get("count"):
                 tags.update({
                     "protected_reasoning_source": protected.get("source", ""),
                     "protected_reasoning_count": protected.get("count", 0),
                     "protected_reasoning_bytes": protected.get("bytes", 0),
                 })
             mspan.set_tags(tags)
-            if start_dt is not None:
-                _set_finish_time_safe(mspan, start_dt)
-            mspan.finish()
-            client.flush()
-            if upload_events:
-                hook_log(f"[rt] upload failed after model flush line={line} detail={upload_events[-1][:500]}")
-                if max_model_line > last_model_line:
-                    state["rt_last_model_line"] = max_model_line
-                return None
-            max_model_line = line
-            model_sent += 1
-        if max_model_line > last_model_line:
-            state["rt_last_model_line"] = max_model_line
-
-        # 线性展开所有 tool_call（带 result 的才算完成），按全局序增量发
-        flat = []
-        for ti, turn in enumerate(turns):
-            results = {r.get("call_id"): r for r in turn.get("tool_results", [])}
-            for tc in turn.get("tool_calls", []):
-                cid = tc.get("call_id")
-                flat.append({"tc": tc, "result": results.get(cid), "turn_index": ti})
-        # 只发已完成（有 result）的，且全局最后一个若无 result 则留到下次
-        completed = []
-        for idx, item in enumerate(flat):
-            is_last = (idx == len(flat) - 1)
-            if item["result"] is not None or (not is_last):
-                completed.append(item)
-        last_tool = state.get("rt_last_tool", 0)
-        new_items = completed[last_tool:]
-        # 批量节流：非终态时距上次上报<5s 则本次不发，攒到下次一起发。终态不节流。
-        if new_items and not is_terminal:
-            since = time.time() - state.get("rt_last_upload_ts", 0)
-            if since < REALTIME_BATCH_INTERVAL:
-                hook_log(f"[rt] batch throttle {since:.1f}s<{REALTIME_BATCH_INTERVAL}s defer {len(new_items)} tool(s)")
-                new_items = []
-        sent = 0
-        for item in new_items:
-            tc = item["tc"]; result = item["result"]
-            gidx = last_tool + sent
-            tname = tc.get("name", "unknown")
-            start_dt = _parse_ts_value(tc.get("_ts"))
-            end_dt = _parse_ts_value(result.get("_ts")) if result else None
-            # 每个 tool_call 用一个 model_call_+tool 子树（与 claude-code 视觉一致）
-            mspan = client.start_span(name=f"model_call_{gidx}", span_type="model",
-                                      start_time=start_dt, child_of=root_ctx)
-            mspan.set_runtime(Runtime(library="codex-cli"))
-            try: mspan.set_model_name(model_name)
-            except Exception: pass
-            if start_dt and end_dt:
-                _set_finish_time_safe(mspan, end_dt)
-            mspan.set_input(truncate_text(_json_text(tc.get("input", {}))))
             mspan_ctx = client.get_span_from_header(mspan.to_header())
             mspan.finish()
 
-            tspan = client.start_span(name=f"tool_{tname}", span_type="tool",
-                                      start_time=start_dt, child_of=mspan_ctx)
-            tspan.set_runtime(Runtime(library="codex-cli"))
-            if end_dt:
-                _set_finish_time_safe(tspan, end_dt)
-            tspan.set_tags({"tool_name": tname, "tool_call_id": tc.get("call_id"), "step_index": gidx})
-            tspan.set_input(truncate_text(_json_text(tc.get("input", {}))))
-            if result is not None:
+            for tool_call in tool_calls:
+                result = tool_call.get("result")
+                if result is None:
+                    continue
+                tool_start_dt = _parse_ts_value(tool_call.get("_ts")) or start_dt
+                tool_end_dt = _parse_ts_value(result.get("_ts")) or tool_start_dt
+                tname = tool_call.get("name", "unknown")
+                tspan = client.start_span(
+                    name=f"tool_{tname}", span_type="tool",
+                    start_time=tool_start_dt, child_of=mspan_ctx,
+                )
+                tspan.set_runtime(Runtime(library="codex-cli"))
+                if tool_end_dt is not None:
+                    _set_finish_time_safe(tspan, _max_dt(tool_start_dt, tool_end_dt))
+                tspan.set_tags({
+                    "tool_name": tname,
+                    "tool_call_id": tool_call.get("call_id"),
+                    "model_invocation_line": line,
+                })
+                tspan.set_input(truncate_text(_json_text(tool_call.get("input", {}))))
                 tspan.set_output(truncate_text(_json_text(result.get("output", ""))))
-            tspan.finish()
-            sent += 1
-            client.flush()  # 每个 tool_call 立即 flush → 结束即可见
-            if upload_events:
-                hook_log(f"[rt] upload failed after tool flush detail={upload_events[-1][:500]}")
-                return None
-
-        state["rt_last_tool"] = last_tool + sent
-        if sent > 0:
-            state["rt_last_upload_ts"] = time.time()
+                tspan.finish()
+                tool_sent += 1
 
-        # --- token_count 独立增量, 与 tool span 同一 root 下, 按行号水位线幂等 ---
-        # 每条 token_count 挂一个 model_usage_<line> span:
-        #   last_token_usage → set_input_tokens/set_output_tokens (SDK 官方求和字段)
-        #   total_token_usage → tags (只观察, 不参与后端聚合, 否则会重复累加)
-        # 只在 flush 成功后推进 rt_last_token_line, 保证上报失败下次能重发.
-        token_sent = 0
-        last_token_line = state.get("rt_last_token_line", -1)
-        pending_tokens = [ev for ev in (token_events or []) if ev["line"] > last_token_line]
-        max_flushed_line = last_token_line
-        for ev in pending_tokens:
-            line = ev["line"]
-            last = ev.get("usage") or {}
-            total = ev.get("total_usage") or {}
-            in_tk = _usage_int(last, "input_tokens")
-            out_tk = _usage_int(last, "output_tokens")
-            start_dt = _parse_ts_value(ev.get("timestamp"))
-            tk_span = client.start_span(name=f"model_usage_{line}", span_type="model",
-                                        start_time=start_dt, child_of=root_ctx)
-            tk_span.set_runtime(Runtime(library="codex-cli"))
-            try: tk_span.set_model_name(model_name)
-            except Exception: pass
-            if start_dt is not None:
-                _set_finish_time_safe(tk_span, start_dt)
-            if in_tk > 0:
-                try: tk_span.set_input_tokens(in_tk)
-                except Exception: pass
-            if out_tk > 0:
-                try: tk_span.set_output_tokens(out_tk)
-                except Exception: pass
-            tk_tags = {
-                "token_event_line": line,
-                "token_source": "codex_token_count",
-                "cached_input_tokens": _usage_int(last, "cached_input_tokens"),
-                "reasoning_output_tokens": _usage_int(last, "reasoning_output_tokens"),
-                "total_tokens": _usage_int(last, "total_tokens"),
-            }
-            if total:
-                tk_tags["total_input_tokens"] = _usage_int(total, "input_tokens")
-                tk_tags["total_output_tokens"] = _usage_int(total, "output_tokens")
-                tk_tags["total_cached_input_tokens"] = _usage_int(total, "cached_input_tokens")
-                tk_tags["total_reasoning_output_tokens"] = _usage_int(total, "reasoning_output_tokens")
-                tk_tags["total_all_tokens"] = _usage_int(total, "total_tokens")
-            tk_span.set_tags(tk_tags)
-            tk_span.finish()
             client.flush()
             if upload_events:
-                hook_log(f"[rt] upload failed after token flush line={line} detail={upload_events[-1][:500]}")
-                if max_flushed_line > last_token_line:
-                    state["rt_last_token_line"] = max_flushed_line
+                hook_log(
+                    f"[rt] upload failed after invocation flush line={line} "
+                    f"detail={upload_events[-1][:500]}"
+                )
                 return None
-            max_flushed_line = line
-            token_sent += 1
-        if token_sent > 0:
-            state["rt_last_token_line"] = max_flushed_line
+            state["rt_last_invocation_line"] = line
+            invocation_sent += 1
+
+        if invocation_sent > 0:
+            state["rt_model_call_count"] = model_call_base + invocation_sent
             state["rt_last_upload_ts"] = time.time()
 
         if is_terminal:
@@ -1774,13 +1894,17 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
             if upload_events:
                 hook_log(f"[rt] upload failed after final flush detail={upload_events[-1][:500]}")
                 return None
-            hook_log(f"[rt] finalized total_tools={state['rt_last_tool']}")
+            hook_log(f"[rt] finalized total_model_calls={state.get('rt_model_call_count', 0)}")
 
         if upload_events:
             hook_log(f"[rt] upload failed state not advanced detail={upload_events[-1][:500]}")
             return None
 
-        hook_log(f"[rt] sent {model_sent} model span(s), {sent} tool span(s), {token_sent} token span(s), last_model_line={state.get('rt_last_model_line', -1)}, last_tool={state['rt_last_tool']}, last_token_line={state.get('rt_last_token_line', -1)}, terminal={is_terminal}")
+        hook_log(
+            f"[rt] sent {invocation_sent} model invocation(s), {tool_sent} tool span(s), "
+            f"last_invocation_line={state.get('rt_last_invocation_line', -1)}, "
+            f"terminal={is_terminal}"
+        )
         return True
     except Exception as e:
         hook_log(f"[rt] error: {e}")
@@ -1855,8 +1979,7 @@ def main():
     state_file = get_state_file_path(transcript_path)
     state = load_state(state_file)
 
-    # 方案 B（实时）：读【全量】entries 重建完整 turn/tool 序列。实时路径用全局 tool 水位线
-    # state["rt_last_tool"] 增量，每次触发把新完成的 tool_call 发出，结束即可见，不节流。
+    # 实时路径读取全量 entries 重建 invocation 序列，再用 token 边界行号水位线增量上报。
     entries = read_rollout_messages(transcript_path, 0)
 
     if not entries:
@@ -1898,9 +2021,13 @@ def main():
 
     # Group entries into turns
     turns = group_messages_into_turns(entries)
-    # 独立扫 token_count 事件, 与 turn 解耦, 走独立行号水位线上报.
-    token_events = extract_token_events(entries)
-    debug_log(f"Grouped into {len(turns)} turns, {len(token_events)} token events")
+    model_invocations = extract_model_invocations(
+        turns, entries, is_terminal=is_terminal_event
+    )
+    debug_log(
+        f"Grouped into {len(turns)} turns, "
+        f"{len(model_invocations)} model invocations"
+    )
 
     # If this is a subagent, save data for parent to include later
     if is_subagent:
@@ -1937,18 +2064,25 @@ def main():
                     break
         coze_tags_override = state.get("coze_tags") or None
 
-        # 方案 B 实时：把新完成的 tool_call 作为 span 挂稳定 root，结束即可见。不节流。
+        # 方案 B 实时：按 token_count 边界把内容、推理、工具调用和 usage 合成 model_call。
         ok = send_steps_realtime(turns, session_id, state, model_name=model_name,
                                  coze_tags_override=coze_tags_override,
                                  is_terminal=is_terminal_event,
-                                 token_events=token_events)
+                                 model_invocations=model_invocations)
         if ok is None:
             hook_log(f"realtime send failed session_id={session_id}")
             debug_log("Realtime send failed, state not advanced")
             return
         save_state(state_file, state)
-        hook_log(f"rt state saved event={hook_event} last_tool={state.get('rt_last_tool')} session_id={session_id}")
-        debug_log(f"State saved. rt_last_tool={state.get('rt_last_tool')}")
+        hook_log(
+            f"rt state saved event={hook_event} "
+            f"last_invocation_line={state.get('rt_last_invocation_line')} "
+            f"session_id={session_id}"
+        )
+        debug_log(
+            f"State saved. rt_last_invocation_line="
+            f"{state.get('rt_last_invocation_line')}"
+        )
     else:
         hook_log(f"skip no turns session_id={session_id}")
         debug_log("No turns to send")

package/scripts/openclaw/dist/index.js

@@ -870,6 +870,34 @@ const cozeloopTracePlugin = {
                 parentSpanId: parentSpanId || ctx.rootSpanId,
             };
         };
+        const nativeTimingAttributes = (timing, fallbackSource = "reconstructed_session") => {
+            if (!timing)
+                return { timing_source: fallbackSource };
+            const attributes = {
+                timing_source: "native_model_call",
+                model_call_id: timing.callId,
+                model_call_outcome: timing.outcome,
+            };
+            if (timing.timeToFirstByteMs !== undefined)
+                attributes.time_to_first_byte_ms = timing.timeToFirstByteMs;
+            if (timing.requestPayloadBytes !== undefined)
+                attributes.request_payload_bytes = timing.requestPayloadBytes;
+            if (timing.responseStreamBytes !== undefined)
+                attributes.response_stream_bytes = timing.responseStreamBytes;
+            if (timing.errorCategory)
+                attributes.error_category = timing.errorCategory;
+            if (timing.failureKind)
+                attributes.failure_kind = timing.failureKind;
+            if (timing.outcome === "error")
+                attributes.error = true;
+            return attributes;
+        };
+        const consumeNativeModelTiming = (ctx) => {
+            const queue = ctx.completedNativeModelCalls;
+            if (!queue || queue.length === 0)
+                return undefined;
+            return queue.shift();
+        };
         const buildReactSpans = async (ctx, channelId, entries, initialInput, agentStartTime, userWrittenAt, skipCount, sessionUserContent) => {
             const entriesToSkip = skipCount || 0;
             const reactMessages = [];
@@ -947,8 +975,9 @@ const cozeloopTracePlugin = {
                         modelSpanCount++;
                         const provider = entry.provider || ctx.lastModelProvider || "unknown";
                         const model = entry.model || ctx.lastModelId || "unknown";
-                        const spanStartTime = prevWrittenAt;
-                        const spanEndTime = entryWrittenAt;
+                        const nativeTiming = consumeNativeModelTiming(ctx);
+                        const spanStartTime = nativeTiming?.startTime ?? prevWrittenAt;
+                        const spanEndTime = nativeTiming?.endTime ?? entryWrittenAt;
                         const tokenUsage = readTokenUsage(entry.usage);
                         const modelSpan = createSpan(ctx, channelId, `${provider}/${model}`, "model", spanStartTime, spanEndTime, {
                             "gen_ai.provider.name": provider,
@@ -959,6 +988,7 @@ const cozeloopTracePlugin = {
                             "input_tokens": tokenUsage.input,
                             "output_tokens": tokenUsage.output,
                             "react_round": reactRound,
+                            ...nativeTimingAttributes(nativeTiming),
                         }, { messages: reactMessages.map((msg) => safeClone(msg)) }, formatAssistantOutput(entry.content, entry.stopReason));
                         await exporter.export(modelSpan);
                     }
@@ -1161,9 +1191,47 @@ const cozeloopTracePlugin = {
                 }
             });
         }
-        let lastLlmInput = undefined;
-        let lastLlmStartTime = undefined;
-        let lastLlmSpanId = undefined;
+        if (shouldHookEnabled("model_call_started")) {
+            on("model_call_started", async (event, hookCtx) => {
+                const rawChannelId = resolveChannelId(hookCtx);
+                const { ctx } = resolveActiveContext(rawChannelId, event.runId, "model_call_started", hookCtx);
+                if (!ctx.nativeModelCallStarts)
+                    ctx.nativeModelCallStarts = new Map();
+                ctx.nativeModelCallStarts.set(event.callId, {
+                    callId: event.callId,
+                    runId: event.runId,
+                    provider: event.provider,
+                    model: event.model,
+                    startTime: Date.now(),
+                });
+            });
+        }
+        if (shouldHookEnabled("model_call_ended")) {
+            on("model_call_ended", async (event, hookCtx) => {
+                const rawChannelId = resolveChannelId(hookCtx);
+                const { ctx } = resolveActiveContext(rawChannelId, event.runId, "model_call_ended", hookCtx);
+                const start = ctx.nativeModelCallStarts?.get(event.callId);
+                if (!start)
+                    return;
+                ctx.nativeModelCallStarts.delete(event.callId);
+                const durationMs = Math.max(0, Number(event.durationMs) || 0);
+                const endTime = Date.now();
+                if (!ctx.completedNativeModelCalls)
+                    ctx.completedNativeModelCalls = [];
+                ctx.completedNativeModelCalls.push({
+                    ...start,
+                    startTime: endTime - durationMs,
+                    endTime,
+                    durationMs,
+                    outcome: event.outcome,
+                    errorCategory: event.errorCategory,
+                    failureKind: event.failureKind,
+                    requestPayloadBytes: event.requestPayloadBytes,
+                    responseStreamBytes: event.responseStreamBytes,
+                    timeToFirstByteMs: event.timeToFirstByteMs,
+                });
+            });
+        }
         if (shouldHookEnabled("llm_input")) {
             on("llm_input", async (event, hookCtx) => {
                 const rawChannelId = resolveChannelId(hookCtx);
@@ -1248,9 +1316,6 @@ const cozeloopTracePlugin = {
                 ctx.llmInput = {
                     "messages": messages,
                 };
-                lastLlmInput = ctx.llmInput;
-                lastLlmStartTime = ctx.llmStartTime;
-                lastLlmSpanId = ctx.llmSpanId;
                 if (config.debug) {
                     api.logger.info(`[CozeloopTrace] LLM input started: ${event.provider}/${event.model}, runId=${event.runId}, traceId=${ctx.traceId}`);
                 }
@@ -1267,7 +1332,7 @@ const cozeloopTracePlugin = {
                 }
                 const { ctx, channelId } = resolveActiveContext(rawChannelId, event.runId, "llm_output", hookCtx);
                 const now = Date.now();
-                const startTime = ctx.llmStartTime || lastLlmStartTime || now;
+                const startTime = ctx.llmStartTime || now;
                 if (event.assistantTexts && event.assistantTexts.length > 0) {
                     const outputText = event.assistantTexts.join("\n");
                     ctx.lastOutput = outputText;
@@ -1279,8 +1344,8 @@ const cozeloopTracePlugin = {
                         api.logger.info(`[CozeloopTrace] Captured output from llm_output (will use last): traceId=${ctx.traceId}, length=${outputText.length}`);
                     }
                 }
-                const llmInput = ctx.llmInput || lastLlmInput;
-                const llmSpanId = ctx.llmSpanId || lastLlmSpanId;
+                const llmInput = ctx.llmInput;
+                const llmSpanId = ctx.llmSpanId;
                 if (config.debug) {
                     api.logger.info(`[CozeloopTrace] llm_output ctx: traceId=${ctx.traceId}, rootSpanId=${ctx.rootSpanId}, llmSpanId=${llmSpanId || "none"}, hasInput=${!!llmInput}`);
                 }
@@ -1289,7 +1354,7 @@ const cozeloopTracePlugin = {
                     const { entries, userWrittenAt, userContent } = readCurrentTurnReactSequence(hookCtx);
                     const hasAssistantEntry = entries.some((e) => e.type === "assistant");
                     if (entries.length > 0 && hasAssistantEntry) {
-                        const agentStart = ctx.agentStartTime || ctx.llmStartTime || lastLlmStartTime || now;
+                        const agentStart = ctx.agentStartTime || ctx.llmStartTime || now;
                         const skipCount = ctx.sessionBasedExportedCount || 0;
                         const modelCount = await buildReactSpans(ctx, channelId, entries, llmInput, agentStart, userWrittenAt, skipCount, userContent);
                         if (modelCount > 0) {
@@ -1332,7 +1397,9 @@ const cozeloopTracePlugin = {
                         "output_tokens": tokenUsage.output,
                     };
                     const finalOutput = formatAssistantOutput(event.assistantTexts?.map((t) => ({ type: "text", text: t })) ?? [], "stop");
-                    const span = createSpan(ctx, channelId, `${event.provider}/${event.model}`, "model", startTime, now, spanAttributes, llmInput, finalOutput);
+                    const nativeTiming = consumeNativeModelTiming(ctx);
+                    Object.assign(spanAttributes, nativeTimingAttributes(nativeTiming, "llm_hooks_fallback"));
+                    const span = createSpan(ctx, channelId, `${event.provider}/${event.model}`, "model", nativeTiming?.startTime ?? startTime, nativeTiming?.endTime ?? now, spanAttributes, llmInput, finalOutput);
                     if (llmSpanId) {
                         span.spanId = llmSpanId;
                     }
@@ -1350,9 +1417,6 @@ const cozeloopTracePlugin = {
                 ctx.reactCount = 0;
                 ctx.pendingToolSpans = undefined;
                 ctx.sessionBasedSpansCreated = undefined;
-                lastLlmInput = undefined;
-                lastLlmStartTime = undefined;
-                lastLlmSpanId = undefined;
             });
         }
         if (shouldHookEnabled("before_tool_call")) {

package/scripts/openclaw/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cozeloop-trace",
   "name": "OpenClaw CozeLoop Trace",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Report OpenClaw execution traces to CozeLoop via OpenTelemetry",
   "type": "plugin",
   "entry": "./dist/index.js",

package/scripts/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cozeloop/openclaw-cozeloop-trace",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "OpenClaw Plugin for reporting traces to CozeLoop via OpenTelemetry",
   "type": "module",
   "main": "dist/index.js",