coze_lab 0.1.55 → 0.1.56

package/package.json

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

@@ -822,6 +822,12 @@ def extract_model_invocations(turns: List[Dict[str, Any]],
     }
     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
@@ -842,7 +848,11 @@ def extract_model_invocations(turns: List[Dict[str, Any]],
         if not has_payload:
             return
         current["line"] = boundary_line
-        current["end_timestamp"] = boundary_ts or current["end_timestamp"]
+        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"))
@@ -866,7 +876,8 @@ def extract_model_invocations(turns: List[Dict[str, Any]],
                 "protected": {"source": "", "count": 0, "bytes": 0},
                 "tool_calls": [],
                 "turn": None,
-                "start_timestamp": None,
+                "start_timestamp": event.get("timestamp"),
+                "start_turn": event.get("turn"),
                 "end_timestamp": None,
                 "line": -1,
                 "usage": {},
@@ -876,7 +887,14 @@ def extract_model_invocations(turns: List[Dict[str, Any]],
             continue
 
         current["turn"] = current["turn"] or event.get("turn")
-        current["start_timestamp"] = current["start_timestamp"] or event.get("timestamp")
+        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":
@@ -944,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":
@@ -1793,6 +1812,7 @@ def send_steps_realtime(turns, session_id, state, model_name="codex", coze_tags_
             tags = {
                 "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"),

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