coze_lab 0.1.30 → 0.1.31

package/package.json

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

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

@@ -1,6 +1,5 @@
 import { trace, context, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { BasicTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { Resource } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_INSTANCE_ID } from "@opentelemetry/semantic-conventions";
 import { hostname } from "os";
@@ -8,6 +7,7 @@ import { basename, join } from "path";
 import { createRequire } from "node:module";
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
+import http from "http";
 import https from "https";
 
 const require = createRequire(import.meta.url);
@@ -78,6 +78,193 @@ async function getRefreshedToken(currentAuthorization, opts = {}) {
 }
 // ─────────────────────────────────────────────────────────────────────────
 
+const EXPORT_SUCCESS = 0;
+const EXPORT_FAILED = 1;
+
+function normalizeTraceUrl(endpoint) {
+    const base = String(endpoint || "").replace(/\/+$/, "");
+    return base.endsWith("/v1/traces") ? base : `${base}/v1/traces`;
+}
+
+function hrTimeToUnixNano(time) {
+    if (Array.isArray(time)) {
+        return (BigInt(time[0]) * 1000000000n + BigInt(time[1])).toString();
+    }
+    const millis = time instanceof Date ? time.getTime() : Number(time || Date.now());
+    return (BigInt(Math.trunc(millis)) * 1000000n).toString();
+}
+
+function spanKindToOtlp(kind) {
+    switch (kind) {
+        case SpanKind.INTERNAL: return 1;
+        case SpanKind.SERVER: return 2;
+        case SpanKind.CLIENT: return 3;
+        case SpanKind.PRODUCER: return 4;
+        case SpanKind.CONSUMER: return 5;
+        default: return 0;
+    }
+}
+
+function scalarToAnyValue(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return { stringValue: value };
+    if (typeof value === "boolean")
+        return { boolValue: value };
+    if (typeof value === "number") {
+        if (Number.isInteger(value))
+            return { intValue: String(value) };
+        return { doubleValue: value };
+    }
+    try {
+        return { stringValue: JSON.stringify(value) };
+    }
+    catch {
+        return { stringValue: String(value) };
+    }
+}
+
+function valueToAnyValue(value) {
+    if (Array.isArray(value)) {
+        const values = value.map(scalarToAnyValue).filter(Boolean);
+        return { arrayValue: { values } };
+    }
+    return scalarToAnyValue(value);
+}
+
+function attributesToOtlp(attributes) {
+    const out = [];
+    for (const [key, value] of Object.entries(attributes || {})) {
+        const otlpValue = valueToAnyValue(value);
+        if (otlpValue) {
+            out.push({ key, value: otlpValue });
+        }
+    }
+    return out;
+}
+
+function spanToOtlp(span) {
+    const spanContext = span.spanContext();
+    const otlpSpan = {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId,
+        name: span.name,
+        kind: spanKindToOtlp(span.kind),
+        startTimeUnixNano: hrTimeToUnixNano(span.startTime),
+        endTimeUnixNano: hrTimeToUnixNano(span.endTime),
+        attributes: attributesToOtlp(span.attributes),
+        status: { code: span.status?.code ?? 0 },
+    };
+    if (span.parentSpanId) {
+        otlpSpan.parentSpanId = span.parentSpanId;
+    }
+    if (span.status?.message) {
+        otlpSpan.status.message = span.status.message;
+    }
+    return otlpSpan;
+}
+
+function buildOtlpTraceRequest(spans) {
+    const resourceGroups = new Map();
+    for (const span of spans) {
+        const resourceAttrs = attributesToOtlp(span.resource?.attributes || {});
+        const scope = span.instrumentationLibrary || {};
+        const scopeData = {
+            name: scope.name || "openclaw-cozeloop-trace",
+            version: scope.version || PLUGIN_VERSION,
+        };
+        if (scope.schemaUrl) {
+            scopeData.schemaUrl = scope.schemaUrl;
+        }
+        const resourceKey = JSON.stringify(resourceAttrs);
+        let resourceGroup = resourceGroups.get(resourceKey);
+        if (!resourceGroup) {
+            resourceGroup = {
+                resource: { attributes: resourceAttrs },
+                scopeGroups: new Map(),
+            };
+            resourceGroups.set(resourceKey, resourceGroup);
+        }
+        const scopeKey = JSON.stringify(scopeData);
+        let scopeGroup = resourceGroup.scopeGroups.get(scopeKey);
+        if (!scopeGroup) {
+            scopeGroup = { scope: scopeData, spans: [] };
+            resourceGroup.scopeGroups.set(scopeKey, scopeGroup);
+        }
+        scopeGroup.spans.push(spanToOtlp(span));
+    }
+    return {
+        resourceSpans: Array.from(resourceGroups.values()).map((resourceGroup) => ({
+            resource: resourceGroup.resource,
+            scopeSpans: Array.from(resourceGroup.scopeGroups.values()),
+        })),
+    };
+}
+
+function postJson(url, body, headers) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const u = new URL(url);
+        const client = u.protocol === "http:" ? http : https;
+        const req = client.request({
+            protocol: u.protocol,
+            hostname: u.hostname,
+            port: u.port || undefined,
+            path: u.pathname + u.search,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(data),
+                ...(headers || {}),
+            },
+        }, (res) => {
+            let buf = "";
+            res.on("data", c => buf += c);
+            res.on("end", () => resolve({ status: res.statusCode || 0, body: buf }));
+        });
+        req.on("error", reject);
+        req.setTimeout(15000, () => req.destroy(new Error("OTLP JSON export timed out")));
+        req.write(data);
+        req.end();
+    });
+}
+
+class JsonOtlpTraceExporter {
+    constructor(config) {
+        this.url = normalizeTraceUrl(config.url);
+        this.headers = config.headers || {};
+        this.logger = config.logger;
+        this.shutdownRequested = false;
+    }
+    export(spans, resultCallback) {
+        if (!spans || spans.length === 0 || this.shutdownRequested) {
+            resultCallback({ code: EXPORT_SUCCESS });
+            return;
+        }
+        this.postSpans(spans)
+            .then(() => resultCallback({ code: EXPORT_SUCCESS }))
+            .catch((err) => {
+                this.logger?.error?.(`[CozeloopTrace] OTLP JSON export failed: ${err?.message || err}`);
+                resultCallback({ code: EXPORT_FAILED, error: err });
+            });
+    }
+    async postSpans(spans) {
+        const body = buildOtlpTraceRequest(spans);
+        const res = await postJson(this.url, body, this.headers);
+        if (res.status < 200 || res.status >= 300) {
+            const snippet = String(res.body || "").slice(0, 300);
+            throw new Error(`HTTP ${res.status}${snippet ? `: ${snippet}` : ""}`);
+        }
+    }
+    async forceFlush() {
+        return;
+    }
+    async shutdown() {
+        this.shutdownRequested = true;
+    }
+}
+
 export class CozeloopExporter {
     config;
     api;
@@ -173,8 +360,9 @@ export class CozeloopExporter {
         const authorization = this.config.authorization;
         const workspaceId = this.config.workspaceId;
         this.api.logger.info(`[CozeloopTrace] Using authorization, workspaceId=${workspaceId}, tokenLength=${authorization?.length}`);
-        const exporter = new OTLPTraceExporter({
+        const exporter = new JsonOtlpTraceExporter({
             url: `${this.config.endpoint}/v1/traces`,
+            logger: this.api.logger,
             headers: {
                 "Authorization": authorization,
                 "cozeloop-workspace-id": workspaceId,
@@ -441,12 +629,22 @@ export class CozeloopExporter {
     }
     async flush() {
         if (this.provider) {
-            await this.provider.forceFlush();
+            try {
+                await this.provider.forceFlush();
+            }
+            catch (err) {
+                this.api.logger.error(`[CozeloopTrace] Flush failed: ${err?.message || err}`);
+            }
         }
     }
     async dispose() {
         if (this.provider) {
-            await this.provider.shutdown();
+            try {
+                await this.provider.shutdown();
+            }
+            catch (err) {
+                this.api.logger.error(`[CozeloopTrace] Shutdown failed: ${err?.message || err}`);
+            }
         }
     }
 }

package/scripts/openclaw/dist/index.js

@@ -481,15 +481,21 @@ function resolveCozeContext(input, sessionId) {
 // use this to ensure every span lands in the same Trace.
 let activeAgentCtx;
 let activeAgentChannelId;
+const activeAgentContextByKey = new Map();
 // Latest user input captured from message_received, independent of any ctx.
 // Used by ensureRootSpan as a reliable fallback for the root span's input.
 let lastUserInput;
-let pendingToolCall;
+const lastUserContextByKey = new Map();
+const pendingToolCallsByKey = new Map();
 function resolveOpenclawSessionId(hookCtx, eventSessionId) {
     const raw = hookCtx.sessionId?.trim() || eventSessionId?.trim();
-    if (!raw)
-        return undefined;
-    return raw;
+    if (raw)
+        return raw;
+    const sessionKey = hookCtx.sessionKey?.trim();
+    const match = sessionKey?.match(/^agent:[^:]+:(.+)$/);
+    if (match?.[1])
+        return match[1];
+    return undefined;
 }
 const cozeloopTracePlugin = {
     id: "openclaw-cozeloop-trace",
@@ -558,6 +564,15 @@ const cozeloopTracePlugin = {
             const ctx = contextByRunId.get(runId);
             return ctx?.originalChannelId || ctx?.channelId;
         };
+        const sessionIdFromChannelId = (channelId) => {
+            const match = String(channelId || "").match(/^agent\/[^:]+:(.+)$/);
+            return match?.[1];
+        };
+        const canFallbackToLastUserContext = (rawChannelId) => {
+            const rawSessionId = sessionIdFromChannelId(rawChannelId);
+            const lastSessionId = lastUserTraceContext?.openclawSessionId || sessionIdFromChannelId(lastUserChannelId);
+            return !rawSessionId || !lastSessionId || rawSessionId === lastSessionId;
+        };
         const startTurn = (runId, channelId, originalChannelId, openclawSessionId) => {
             const traceId = generateId(32);
             const ctx = {
@@ -594,7 +609,7 @@ const cozeloopTracePlugin = {
             if (!activeCtx) {
                 activeCtx = getContextByRun(effectiveRunId);
             }
-            if (!activeCtx && rawChannelId.startsWith("agent/") && lastUserTraceContext) {
+            if (!activeCtx && rawChannelId.startsWith("agent/") && lastUserTraceContext && canFallbackToLastUserContext(rawChannelId)) {
                 activeCtx = lastUserTraceContext;
                 channelId = lastUserChannelId || channelId;
                 contextByChannelId.set(rawChannelId, activeCtx);
@@ -616,19 +631,136 @@ const cozeloopTracePlugin = {
             }
             return { ctx: activeCtx, channelId, isNew };
         };
+        const contextKeys = (hookCtx, channelId, eventSessionId) => {
+            const keys = [];
+            const add = (value) => {
+                const s = String(value || "").trim();
+                if (s && !keys.includes(s))
+                    keys.push(s);
+            };
+            add(resolveOpenclawSessionId(hookCtx || {}, eventSessionId));
+            add(hookCtx?.sessionKey);
+            add(hookCtx?.conversationId);
+            add(channelId);
+            return keys;
+        };
+        const rememberLastUserContext = (hookCtx, channelId, ctx) => {
+            for (const key of contextKeys(hookCtx, channelId)) {
+                lastUserContextByKey.set(key, { ctx, channelId });
+            }
+        };
+        const resolveLastUserContext = (hookCtx, channelId) => {
+            for (const key of contextKeys(hookCtx, channelId)) {
+                const found = lastUserContextByKey.get(key);
+                if (found)
+                    return found;
+            }
+            if (lastUserTraceContext) {
+                return { ctx: lastUserTraceContext, channelId: lastUserChannelId || channelId };
+            }
+            return undefined;
+        };
+        const rememberActiveAgentContext = (hookCtx, channelId, ctx) => {
+            for (const key of contextKeys(hookCtx, channelId, ctx.openclawSessionId)) {
+                activeAgentContextByKey.set(key, { ctx, channelId });
+            }
+            activeAgentCtx = ctx;
+            activeAgentChannelId = channelId;
+        };
+        const resolveActiveAgentContext = (hookCtx, channelId) => {
+            for (const key of contextKeys(hookCtx, channelId)) {
+                const found = activeAgentContextByKey.get(key);
+                if (found)
+                    return found;
+            }
+            if (activeAgentCtx) {
+                return { ctx: activeAgentCtx, channelId: activeAgentChannelId || channelId };
+            }
+            return undefined;
+        };
+        const clearActiveAgentContext = (ctx) => {
+            for (const [key, found] of activeAgentContextByKey.entries()) {
+                if (found.ctx === ctx)
+                    activeAgentContextByKey.delete(key);
+            }
+            if (activeAgentCtx === ctx) {
+                activeAgentCtx = undefined;
+                activeAgentChannelId = undefined;
+            }
+        };
+        const clearLastUserContext = (ctx) => {
+            for (const [key, found] of lastUserContextByKey.entries()) {
+                if (found.ctx === ctx)
+                    lastUserContextByKey.delete(key);
+            }
+            if (lastUserTraceContext === ctx) {
+                lastUserTraceContext = undefined;
+                lastUserChannelId = undefined;
+            }
+        };
         // Resolve context for hooks that fire between before_agent_start and
         // agent_end.  When an agent is active, always return that agent's context
         // so every span ends up in the same Trace regardless of channelId drift.
-        const resolveActiveContext = (rawChannelId, runId, hookName) => {
-            if (activeAgentCtx) {
+        const resolveActiveContext = (rawChannelId, runId, hookName, hookCtx) => {
+            const active = resolveActiveAgentContext(hookCtx || {}, rawChannelId);
+            if (active) {
                 if (config.debug) {
-                    api.logger.info(`[CozeloopTrace] Using activeAgentCtx for ${hookName}: traceId=${activeAgentCtx.traceId}, rootSpanId=${activeAgentCtx.rootSpanId}`);
+                    api.logger.info(`[CozeloopTrace] Using activeAgentCtx for ${hookName}: traceId=${active.ctx.traceId}, rootSpanId=${active.ctx.rootSpanId}`);
                 }
-                return { ctx: activeAgentCtx, channelId: activeAgentChannelId || rawChannelId };
+                return active;
             }
             const { ctx, channelId } = getOrCreateContext(rawChannelId, runId, hookName);
             return { ctx, channelId };
         };
+        const getToolCallId = (event) => {
+            const candidates = [
+                event?.toolCallId,
+                event?.tool_call_id,
+                event?.callId,
+                event?.id,
+                event?.requestId,
+                event?.invocationId,
+                event?.params?.toolCallId,
+                event?.params?.tool_call_id,
+            ];
+            const found = candidates.find((value) => value !== undefined && value !== null && String(value).trim());
+            return found === undefined ? undefined : String(found);
+        };
+        const pendingToolKey = (ctx, channelId, toolName, toolCallId) => {
+            const traceKey = ctx.rootSpanId || ctx.traceId || channelId;
+            if (toolCallId)
+                return `${traceKey}:id:${toolCallId}`;
+            return `${traceKey}:name:${toolName || "unknown_tool"}`;
+        };
+        const pushPendingToolCall = (ctx, channelId, pending) => {
+            const key = pendingToolKey(ctx, channelId, pending.toolName, pending.toolCallId);
+            const queue = pendingToolCallsByKey.get(key) || [];
+            queue.push(pending);
+            pendingToolCallsByKey.set(key, queue);
+            return queue.length;
+        };
+        const shiftPendingToolCall = (ctx, channelId, toolName, toolCallId) => {
+            const key = pendingToolKey(ctx, channelId, toolName, toolCallId);
+            const queue = pendingToolCallsByKey.get(key);
+            if (!queue || queue.length === 0)
+                return undefined;
+            const pending = queue.shift();
+            if (queue.length === 0) {
+                pendingToolCallsByKey.delete(key);
+            }
+            return pending;
+        };
+        const clearPendingToolCallsForContext = (ctx) => {
+            for (const [key, queue] of pendingToolCallsByKey.entries()) {
+                const kept = queue.filter((pending) => pending.traceContext !== ctx);
+                if (kept.length === 0) {
+                    pendingToolCallsByKey.delete(key);
+                }
+                else if (kept.length !== queue.length) {
+                    pendingToolCallsByKey.set(key, kept);
+                }
+            }
+        };
         const createSpan = (ctx, channelId, name, type, startTime, endTime, attributes = {}, input, output, parentSpanId) => {
             return {
                 name,
@@ -878,6 +1010,7 @@ const cozeloopTracePlugin = {
                 if (role === "user" || !role) {
                     lastUserChannelId = channelId;
                     lastUserTraceContext = ctx;
+                    rememberLastUserContext(hookCtx, channelId, ctx);
                     ctx.userInput = event.content;
                     lastUserInput = event.content;
                     rememberCozeContext(event.content, ctx.openclawSessionId || lastOpenclawSessionId);
@@ -891,20 +1024,22 @@ const cozeloopTracePlugin = {
                 if (!lastUserTraceContext) {
                     lastUserTraceContext = ctx;
                     lastUserChannelId = channelId;
+                    rememberLastUserContext(hookCtx, channelId, ctx);
                 }
             });
         }
         if (shouldHookEnabled("message_sending")) {
             on("message_sending", async (event, hookCtx) => {
-                if (lastUserTraceContext) {
-                    lastUserTraceContext.lastOutput = event.content;
+                const rawChannelId = resolveChannelId(hookCtx, event.to);
+                const lastUser = resolveLastUserContext(hookCtx, rawChannelId);
+                if (lastUser) {
+                    lastUser.ctx.lastOutput = event.content;
                     if (config.debug) {
-                        api.logger.info(`[CozeloopTrace] Captured output for root span: traceId=${lastUserTraceContext.traceId}, content=${typeof event.content === 'string' ? event.content.substring(0, 100) : 'non-string'}`);
+                        api.logger.info(`[CozeloopTrace] Captured output for root span: traceId=${lastUser.ctx.traceId}, content=${typeof event.content === 'string' ? event.content.substring(0, 100) : 'non-string'}`);
                     }
                 }
                 else {
-                    const rawChannelId = resolveChannelId(hookCtx, event.to);
-                    const { ctx } = resolveActiveContext(rawChannelId, undefined, "message_sending");
+                    const { ctx } = resolveActiveContext(rawChannelId, undefined, "message_sending", hookCtx);
                     ctx.lastOutput = event.content;
                     if (config.debug) {
                         api.logger.info(`[CozeloopTrace] Captured output (fallback) for root span: traceId=${ctx.traceId}`);
@@ -915,15 +1050,16 @@ const cozeloopTracePlugin = {
         if (shouldHookEnabled("message_sent")) {
             on("message_sent", async (event, hookCtx) => {
                 if (event.content && event.success) {
-                    if (lastUserTraceContext) {
-                        lastUserTraceContext.lastOutput = event.content;
+                    const rawChannelId = resolveChannelId(hookCtx, event.to);
+                    const lastUser = resolveLastUserContext(hookCtx, rawChannelId);
+                    if (lastUser) {
+                        lastUser.ctx.lastOutput = event.content;
                         if (config.debug) {
-                            api.logger.info(`[CozeloopTrace] Captured output from message_sent: traceId=${lastUserTraceContext.traceId}`);
+                            api.logger.info(`[CozeloopTrace] Captured output from message_sent: traceId=${lastUser.ctx.traceId}`);
                         }
                     }
                     else {
-                        const rawChannelId = resolveChannelId(hookCtx, event.to);
-                        const { ctx } = resolveActiveContext(rawChannelId, undefined, "message_sent");
+                        const { ctx } = resolveActiveContext(rawChannelId, undefined, "message_sent", hookCtx);
                         ctx.lastOutput = event.content;
                         if (config.debug) {
                             api.logger.info(`[CozeloopTrace] Captured output from message_sent (fallback): traceId=${ctx.traceId}`);
@@ -941,7 +1077,7 @@ const cozeloopTracePlugin = {
                 if (config.debug) {
                     api.logger.info(`[CozeloopTrace] llm_input hookCtx: ${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, event.runId=${event.runId}`);
                 }
-                const { ctx } = resolveActiveContext(rawChannelId, event.runId, "llm_input");
+                const { ctx, channelId } = resolveActiveContext(rawChannelId, event.runId, "llm_input", hookCtx);
                 const ocSessionId = resolveOpenclawSessionId(hookCtx);
                 if (ocSessionId) {
                     ctx.openclawSessionId = ocSessionId;
@@ -966,9 +1102,10 @@ const cozeloopTracePlugin = {
                 rememberCozeContext(event.prompt, ctx.openclawSessionId || lastOpenclawSessionId);
                 // Fallback: ensure root + agent spans exist in case before_agent_start
                 // was not fired (older OpenClaw versions or resumed sessions).
-                const channelIdForSpans = activeAgentChannelId || rawChannelId;
+                const active = resolveActiveAgentContext(hookCtx, channelId);
+                const channelIdForSpans = active?.channelId || channelId || rawChannelId;
                 await ensureRootSpan(ctx, channelIdForSpans);
-                await ensureAgentSpan(ctx, channelIdForSpans);
+                await ensureAgentSpan(ctx, channelIdForSpans, undefined, hookCtx);
                 const messages = [];
                 if (event.systemPrompt) {
                     messages.push({ role: "system", content: safeClone(event.systemPrompt) });
@@ -1035,14 +1172,15 @@ const cozeloopTracePlugin = {
                     api.logger.info(`[CozeloopTrace][DEBUG] llm_output event keys=${JSON.stringify(Object.keys(event))}`);
                     api.logger.info(`[CozeloopTrace] llm_output hookCtx: ${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, event.runId=${event.runId}`);
                 }
-                const { ctx, channelId } = resolveActiveContext(rawChannelId, event.runId, "llm_output");
+                const { ctx, channelId } = resolveActiveContext(rawChannelId, event.runId, "llm_output", hookCtx);
                 const now = Date.now();
                 const startTime = ctx.llmStartTime || lastLlmStartTime || now;
                 if (event.assistantTexts && event.assistantTexts.length > 0) {
                     const outputText = event.assistantTexts.join("\n");
                     ctx.lastOutput = outputText;
-                    if (lastUserTraceContext) {
-                        lastUserTraceContext.lastOutput = outputText;
+                    const lastUser = resolveLastUserContext(hookCtx, channelId);
+                    if (lastUser) {
+                        lastUser.ctx.lastOutput = outputText;
                     }
                     if (config.debug) {
                         api.logger.info(`[CozeloopTrace] Captured output from llm_output (will use last): traceId=${ctx.traceId}, length=${outputText.length}`);
@@ -1128,34 +1266,39 @@ const cozeloopTracePlugin = {
                 if (config.debug) {
                     api.logger.info(`[CozeloopTrace] before_tool_call hookCtx: ${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, toolName=${event.toolName}`);
                 }
-                const { ctx, channelId } = resolveActiveContext(rawChannelId, undefined, "before_tool_call");
-                pendingToolCall = {
+                const { ctx, channelId } = resolveActiveContext(rawChannelId, undefined, "before_tool_call", hookCtx);
+                const pendingToolCall = {
                     toolName: event.toolName,
+                    toolCallId: getToolCallId(event),
                     toolSpanId: generateId(16),
                     toolStartTime: Date.now(),
                     toolInput: event.params,
                     traceContext: ctx,
                     channelId: channelId,
                 };
+                const pendingCount = pushPendingToolCall(ctx, channelId, pendingToolCall);
                 ctx.reactCount = (ctx.reactCount || 0) + 1;
                 if (config.debug) {
-                    api.logger.info(`[CozeloopTrace] Tool call started: ${event.toolName}, spanId=${pendingToolCall.toolSpanId}, traceId=${ctx.traceId}`);
+                    api.logger.info(`[CozeloopTrace] Tool call started: ${event.toolName}, toolCallId=${pendingToolCall.toolCallId || "none"}, spanId=${pendingToolCall.toolSpanId}, traceId=${ctx.traceId}, pendingCount=${pendingCount}`);
                 }
             });
         }
         if (shouldHookEnabled("after_tool_call")) {
             on("after_tool_call", async (event, hookCtx) => {
+                const rawChannelId = resolveChannelId(hookCtx);
+                const { ctx, channelId } = resolveActiveContext(rawChannelId, undefined, "after_tool_call", hookCtx);
                 if (config.debug) {
                     api.logger.info(`[CozeloopTrace] after_tool_call hookCtx: ${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}, toolName=${event.toolName}`);
                 }
-                if (!pendingToolCall || pendingToolCall.toolName !== event.toolName) {
+                const toolCallId = getToolCallId(event);
+                const pendingToolCall = shiftPendingToolCall(ctx, channelId, event.toolName, toolCallId);
+                if (!pendingToolCall) {
                     if (config.debug) {
-                        api.logger.info(`[CozeloopTrace] Skipping after_tool_call: no pending tool or name mismatch, toolName=${event.toolName}, pending=${pendingToolCall?.toolName}`);
+                        api.logger.info(`[CozeloopTrace] Skipping after_tool_call: no pending tool, toolName=${event.toolName}, toolCallId=${toolCallId || "none"}, pendingKeys=${pendingToolCallsByKey.size}`);
                     }
                     return;
                 }
                 const { toolName, toolSpanId, toolStartTime, toolInput, traceContext } = pendingToolCall;
-                pendingToolCall = undefined;
                 const now = Date.now();
                 if (!traceContext.pendingToolSpans) {
                     traceContext.pendingToolSpans = [];
@@ -1177,11 +1320,12 @@ const cozeloopTracePlugin = {
         // Helper: finalize a trace — end agent span (if open), end root span, flush,
         // and clean up all state.  Called from agent_end (normal path) and
         // session_end (fallback for old OpenClaw versions that don't emit agent_end).
-        let traceFinalized = false;
+        const finalizingTraces = new Set();
         const finalizeTrace = (ctx, channelId, agentEndAttrs, agentOutput) => {
-            if (traceFinalized)
+            const finalizeKey = ctx.rootSpanId || ctx.traceId;
+            if (finalizingTraces.has(finalizeKey))
                 return;
-            traceFinalized = true;
+            finalizingTraces.add(finalizeKey);
             const now = Date.now();
             // End agent span if still open.
             if (ctx.agentSpanId) {
@@ -1215,20 +1359,17 @@ const cozeloopTracePlugin = {
                 }
                 await exporter.flush();
                 exporter.endTrace(rootSpanId);
-                if (activeAgentCtx === ctx) {
-                    activeAgentCtx = undefined;
-                    activeAgentChannelId = undefined;
-                }
+                clearPendingToolCallsForContext(ctx);
+                clearActiveAgentContext(ctx);
                 if (savedLastUserChannelId) {
                     endTurn(savedLastUserChannelId);
                 }
                 if (originalChannelId && originalChannelId !== savedLastUserChannelId) {
                     endTurn(originalChannelId);
                 }
-                lastUserChannelId = undefined;
-                lastUserTraceContext = undefined;
+                clearLastUserContext(ctx);
                 lastUserInput = undefined;
-                traceFinalized = false;
+                finalizingTraces.delete(finalizeKey);
             }, 200);
         };
         // OpenClaw runtime 周期性发送的心跳轮询消息，不是真实对话，整条 trace 丢弃。
@@ -1322,9 +1463,11 @@ const cozeloopTracePlugin = {
         };
         // Helper: ensure the agent span exists for a given context.
         // Safe to call multiple times — only creates the span once.
-        const ensureAgentSpan = async (ctx, channelId, agentId) => {
-            if (ctx.agentSpanId)
+        const ensureAgentSpan = async (ctx, channelId, agentId, hookCtx) => {
+            if (ctx.agentSpanId) {
+                rememberActiveAgentContext(hookCtx || {}, channelId, ctx);
                 return;
+            }
             const effectiveAgentId = agentId || "main";
             const now = Date.now();
             ctx.agentStartTime = now;
@@ -1347,8 +1490,7 @@ const cozeloopTracePlugin = {
             };
             await exporter.startSpan(spanData, ctx.agentSpanId);
             // Set active agent context so all subsequent hooks use the same Trace.
-            activeAgentCtx = ctx;
-            activeAgentChannelId = channelId;
+            rememberActiveAgentContext(hookCtx || {}, channelId, ctx);
             if (config.debug) {
                 api.logger.info(`[CozeloopTrace] ensureAgentSpan: created agent span, agentId=${effectiveAgentId}, spanId=${ctx.agentSpanId}, traceId=${ctx.traceId}`);
             }
@@ -1368,7 +1510,7 @@ const cozeloopTracePlugin = {
                 }
                 ctx.openclawSessionId = ctx.openclawSessionId || lastOpenclawSessionId;
                 await ensureRootSpan(ctx, channelId);
-                await ensureAgentSpan(ctx, channelId, agentId);
+                await ensureAgentSpan(ctx, channelId, agentId, hookCtx);
             });
         }
         if (shouldHookEnabled("agent_end")) {
@@ -1378,8 +1520,9 @@ const cozeloopTracePlugin = {
                     api.logger.info(`[CozeloopTrace] agent_end hookCtx: ${JSON.stringify({ channelId: hookCtx.channelId, sessionKey: hookCtx.sessionKey, conversationId: hookCtx.conversationId })}`);
                 }
                 // Use activeAgentCtx if available, otherwise fall back to resolution.
-                const ctx = activeAgentCtx || getOrCreateContext(rawChannelId, undefined, "agent_end").ctx;
-                const channelId = activeAgentChannelId || rawChannelId;
+                const active = resolveActiveAgentContext(hookCtx, rawChannelId);
+                const ctx = active?.ctx || getOrCreateContext(rawChannelId, undefined, "agent_end").ctx;
+                const channelId = active?.channelId || rawChannelId;
                 finalizeTrace(ctx, channelId, {
                     "agent.duration_ms": event.durationMs || 0,
                     "agent.message_count": event.messageCount || 0,
@@ -1397,9 +1540,11 @@ const cozeloopTracePlugin = {
                 if (config.debug) {
                     api.logger.info(`[CozeloopTrace] session_end: ${rawChannelId}`);
                 }
-                const ctx = activeAgentCtx || lastUserTraceContext;
+                const active = resolveActiveAgentContext(hookCtx, rawChannelId);
+                const lastUser = resolveLastUserContext(hookCtx, rawChannelId);
+                const ctx = active?.ctx || lastUser?.ctx;
                 if (ctx && ctx.rootSpanStartTime) {
-                    const channelId = activeAgentChannelId || lastUserChannelId || rawChannelId;
+                    const channelId = active?.channelId || lastUser?.channelId || rawChannelId;
                     if (config.debug) {
                         api.logger.info(`[CozeloopTrace] session_end: finalizing trace as fallback, traceId=${ctx.traceId}`);
                     }

package/scripts/openclaw/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cozeloop-trace",
   "name": "OpenClaw CozeLoop Trace",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "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.14",
+  "version": "0.1.15",
   "description": "OpenClaw Plugin for reporting traces to CozeLoop via OpenTelemetry",
   "type": "module",
   "main": "dist/index.js",
@@ -37,7 +37,6 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.7.0",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.48.0",
     "@opentelemetry/resources": "^1.22.0",
     "@opentelemetry/sdk-trace-base": "^1.22.0",
     "@opentelemetry/semantic-conventions": "^1.22.0"