coze_lab 0.1.30 → 0.1.32

package/index.js

@@ -5393,6 +5393,12 @@ function getCloudCozeloopApiBaseUrl() {
 function normalizeCozeloopApiBaseUrl(raw) {
   const base = raw.trim().replace(/\/+$/, '');
   if (!base) return '';
+  if (base.endsWith('/v1/loop/traces/ingest')) {
+    return base.slice(0, -'/v1/loop/traces/ingest'.length).replace(/\/+$/, '');
+  }
+  if (base.endsWith('/api/v1/loop/traces/ingest')) {
+    return base.slice(0, -'/v1/loop/traces/ingest'.length).replace(/\/+$/, '');
+  }
   if (base.endsWith('/v1/loop/opentelemetry/v1/traces')) {
     return base.slice(0, -'/v1/loop/opentelemetry/v1/traces'.length).replace(/\/+$/, '');
   }
@@ -5431,6 +5437,14 @@ function getOtelTracesUrl(cloud) {
   return `${getOtelEndpointBase(cloud).replace(/\/+$/, '')}/v1/traces`;
 }
 
+function getCozeloopIngestUrlFromBase(apiBase) {
+  return `${String(apiBase || COZE_API).replace(/\/+$/, '')}/v1/loop/traces/ingest`;
+}
+
+function getCozeloopIngestUrl(cloud) {
+  return getCozeloopIngestUrlFromBase(getCozeloopApiBaseUrl(cloud));
+}
+
 function applyOpenClawPluginConfig(existing, token, workspaceId, agentId, cloud) {
   if (!existing.plugins)         existing.plugins = {};
   if (!existing.plugins.allow)   existing.plugins.allow = [];
@@ -5450,7 +5464,9 @@ function applyOpenClawPluginConfig(existing, token, workspaceId, agentId, cloud)
   if (!existing.plugins.entries[PLUGIN].config) existing.plugins.entries[PLUGIN].config = {};
   const pcfg = existing.plugins.entries[PLUGIN].config;
   pcfg.authorization = `Bearer ${token}`;
-  pcfg.endpoint      = getOtelEndpointBase(cloud);
+  // OpenClaw runtime uses CozeLoop ingest protocol, not OTLP. Keep accepting
+  // OTEL_ENDPOINT in cloud, but normalize it to the API base URL before writing.
+  pcfg.endpoint      = getCozeloopApiBaseUrl(cloud);
   pcfg.workspaceId   = workspaceId;
   pcfg.debug         = true;
   pcfg.disableLocalCredentials = !!cloud;
@@ -5848,48 +5864,50 @@ async function verifyOpenClawTraceLink(cloud) {
     return { success: false, status: 0, body: 'plugin authorization missing' };
   }
 
-  // 1) 用插件【实际配置的】token 打一条最小 OTLP trace ——这才是运行时真实用的那个 token。
-  //    不能发空 resourceSpans，CozeLoop 会返回 "unknown event type"，导致自检假失败。
+  // 1) 用插件【实际配置的】token 打一条最小 CozeLoop ingest trace ——这才是运行时真实用的那个 token。
   const authHeader = pcfg.authorization; // 形如 "Bearer czu_xxx"
-  const tracesUrl = (pcfg.endpoint
-    ? `${String(pcfg.endpoint).replace(/\/+$/, '')}/v1/traces`
-    : getOtelTracesUrl(cloud));
+  const tracesUrl = getCozeloopIngestUrlFromBase(normalizeCozeloopApiBaseUrl(pcfg.endpoint || getCozeloopApiBaseUrl(cloud)));
   const workspaceId = pcfg.workspaceId || WORKSPACE_ID;
   const traceId = crypto.randomBytes(16).toString('hex');
   const spanId = crypto.randomBytes(8).toString('hex');
-  const nowNs = String(Date.now() * 1_000_000);
+  const nowMicros = Date.now() * 1000;
   const pair = crypto.randomBytes(6).toString('hex');
-  const otlpBody = {
-    resourceSpans: [{
-      resource: {
-        attributes: [
-          { key: 'service.name', value: { stringValue: 'cozelab-onboard-openclaw' } },
-        ],
+  const ingestBody = {
+    spans: [{
+      started_at_micros: nowMicros,
+      log_id: '',
+      span_id: spanId,
+      parent_id: '0',
+      trace_id: traceId,
+      duration_micros: 1,
+      service_name: 'cozelab-onboard-openclaw',
+      workspace_id: String(workspaceId),
+      span_name: 'cozelab-onboard-openclaw-selfcheck',
+      span_type: 'main',
+      status_code: 0,
+      input: 'cozelab-onboard-openclaw selfcheck',
+      output: 'ok',
+      object_storage: '',
+      system_tags_string: {
+        runtime: JSON.stringify({ language: 'nodejs', library: 'openclaw', scene: process.env.COZELOOP_SCENE || 'custom' }),
       },
-      scopeSpans: [{
-        scope: { name: 'cozelab-onboard-openclaw-selfcheck' },
-        spans: [{
-          traceId,
-          spanId,
-          name: 'cozelab-onboard-openclaw-selfcheck',
-          kind: 1,
-          startTimeUnixNano: nowNs,
-          endTimeUnixNano: nowNs,
-          status: { code: 1 },
-          attributes: [
-            { key: 'pair_code', value: { stringValue: pair } },
-            { key: 'source', value: { stringValue: 'cozelab-onboard-openclaw' } },
-          ],
-        }],
-      }],
+      system_tags_long: {},
+      system_tags_double: {},
+      tags_string: {
+        pair_code: pair,
+        source: 'cozelab-onboard-openclaw',
+      },
+      tags_long: {},
+      tags_double: {},
+      tags_bool: {},
     }],
   };
   let res;
   try {
     res = await httpsPost(
       tracesUrl,
-      otlpBody,
-      { Authorization: authHeader, 'cozeloop-workspace-id': String(workspaceId) },
+      ingestBody,
+      { Authorization: authHeader },
     );
   } catch (e) {
     warn(`openclaw 插件 token 上报探测失败: ${e.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "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,238 @@ async function getRefreshedToken(currentAuthorization, opts = {}) {
 }
 // ─────────────────────────────────────────────────────────────────────────
 
+const EXPORT_SUCCESS = 0;
+const EXPORT_FAILED = 1;
+const INGEST_TRACE_PATH = "/v1/loop/traces/ingest";
+
+function normalizeApiBaseUrl(endpoint) {
+    const base = String(endpoint || "").replace(/\/+$/, "");
+    if (!base)
+        return _COZE_API;
+    const suffixes = [
+        "/v1/loop/traces/ingest",
+        "/api/v1/loop/traces/ingest",
+        "/v1/loop/opentelemetry/v1/traces",
+        "/api/v1/loop/opentelemetry/v1/traces",
+        "/v1/loop/opentelemetry",
+        "/api/v1/loop/opentelemetry",
+        "/v1/traces",
+        "/api/v1",
+    ];
+    for (const suffix of suffixes) {
+        if (base.endsWith(suffix)) {
+            const trimSuffix = suffix.startsWith("/api/") ? suffix.slice("/api".length) : suffix;
+            return base.slice(0, -trimSuffix.length).replace(/\/+$/, "");
+        }
+    }
+    return base;
+}
+
+function normalizeIngestUrl(endpoint) {
+    const base = String(endpoint || "").replace(/\/+$/, "");
+    if (base.endsWith(INGEST_TRACE_PATH))
+        return base;
+    return `${normalizeApiBaseUrl(base)}${INGEST_TRACE_PATH}`;
+}
+
+function hrTimeToUnixMicros(time) {
+    if (Array.isArray(time)) {
+        return Number(BigInt(time[0]) * 1000000n + BigInt(Math.trunc(time[1] / 1000)));
+    }
+    const millis = time instanceof Date ? time.getTime() : Number(time || Date.now());
+    return Math.trunc(millis * 1000);
+}
+
+function hrDurationToMicros(duration) {
+    if (Array.isArray(duration)) {
+        return Number(BigInt(duration[0]) * 1000000n + BigInt(Math.trunc(duration[1] / 1000)));
+    }
+    return 0;
+}
+
+function safeStringify(value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+
+function mapSpanType(type) {
+    switch (type) {
+        case "entry":
+        case "gateway":
+        case "message":
+        case "session":
+            return "main";
+        case "agent":
+        case "model":
+        case "tool":
+            return type;
+        default:
+            return type || "main";
+    }
+}
+
+function putTypedTag(maps, key, value) {
+    if (value === undefined || value === null || key === "")
+        return;
+    if (key === "cozeloop.span_type" || key === "cozeloop.input" || key === "cozeloop.output" ||
+        key === "cozeloop.system_tag_runtime") {
+        return;
+    }
+    if (typeof value === "boolean") {
+        maps.bool[key] = value;
+    }
+    else if (typeof value === "number" && Number.isInteger(value)) {
+        maps.long[key] = value;
+    }
+    else if (typeof value === "number") {
+        maps.double[key] = value;
+    }
+    else {
+        maps.string[key] = typeof value === "string" ? value : safeStringify(value);
+    }
+}
+
+function splitAttributes(attributes) {
+    const tags = { string: {}, long: {}, double: {}, bool: {} };
+    const systemTags = { string: {}, long: {}, double: {} };
+    for (const [key, value] of Object.entries(attributes || {})) {
+        if (key === "cozeloop.system_tag_runtime") {
+            systemTags.string.runtime = safeStringify(value);
+            continue;
+        }
+        putTypedTag(tags, key, value);
+    }
+    return { tags, systemTags };
+}
+
+function spanToUploadSpan(span, config) {
+    const spanContext = span.spanContext();
+    const attrs = span.attributes || {};
+    const { tags, systemTags } = splitAttributes(attrs);
+    const resourceAttrs = span.resource?.attributes || {};
+    const serviceName = resourceAttrs["service.name"] || config.serviceName || "openclaw-agent";
+    const spanType = mapSpanType(attrs["cozeloop.span_type"]);
+    const input = attrs["cozeloop.input"] !== undefined ? safeStringify(attrs["cozeloop.input"]) : "";
+    const output = attrs["cozeloop.output"] !== undefined ? safeStringify(attrs["cozeloop.output"]) : "";
+    const hasError = span.status?.code === SpanStatusCode.ERROR || attrs.error === true || attrs["tool.error"] === true;
+
+    return {
+        started_at_micros: hrTimeToUnixMicros(span.startTime),
+        log_id: "",
+        traceId: spanContext.traceId,
+        trace_id: spanContext.traceId,
+        span_id: spanContext.spanId,
+        parent_id: span.parentSpanId || "0",
+        duration_micros: hrDurationToMicros(span.duration),
+        service_name: String(serviceName),
+        workspace_id: String(config.workspaceId || ""),
+        span_name: String(span.name || "unknown"),
+        span_type: spanType,
+        status_code: hasError ? -1 : 0,
+        input,
+        output,
+        object_storage: "",
+        system_tags_string: systemTags.string,
+        system_tags_long: systemTags.long,
+        system_tags_double: systemTags.double,
+        tags_string: tags.string,
+        tags_long: tags.long,
+        tags_double: tags.double,
+        tags_bool: tags.bool,
+    };
+}
+
+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("CozeLoop ingest export timed out")));
+        req.write(data);
+        req.end();
+    });
+}
+
+class CozeloopIngestExporter {
+    constructor(config) {
+        this.url = normalizeIngestUrl(config.endpoint || config.url);
+        this.headers = config.headers || {};
+        this.logger = config.logger;
+        this.workspaceId = config.workspaceId;
+        this.serviceName = config.serviceName;
+        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] CozeLoop ingest export failed: ${err?.message || err}`);
+                resultCallback({ code: EXPORT_FAILED, error: err });
+            });
+    }
+    async postSpans(spans) {
+        const body = {
+            spans: spans.map((span) => spanToUploadSpan(span, {
+                workspaceId: this.workspaceId,
+                serviceName: this.serviceName,
+            })),
+        };
+        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}` : ""}`);
+        }
+        if (res.body) {
+            try {
+                const parsed = JSON.parse(res.body);
+                if (parsed && parsed.code !== undefined && parsed.code !== 0) {
+                    throw new Error(`code ${parsed.code}: ${parsed.msg || res.body.slice(0, 300)}`);
+                }
+            }
+            catch (err) {
+                if (/^code\s/.test(String(err?.message || ""))) {
+                    throw err;
+                }
+            }
+        }
+    }
+    async forceFlush() {
+        return;
+    }
+    async shutdown() {
+        this.shutdownRequested = true;
+    }
+}
+
 export class CozeloopExporter {
     config;
     api;
@@ -173,11 +405,13 @@ 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({
-            url: `${this.config.endpoint}/v1/traces`,
+        const exporter = new CozeloopIngestExporter({
+            endpoint: this.config.endpoint,
+            logger: this.api.logger,
+            workspaceId,
+            serviceName: this.config.serviceName,
             headers: {
                 "Authorization": authorization,
-                "cozeloop-workspace-id": workspaceId,
                 "x-tt-env": "ppe_cozelab",
                 "x-use-ppe": "1",
             },
@@ -441,12 +675,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

@@ -476,20 +476,39 @@ function resolveCozeContext(input, sessionId) {
         return cozeContextBySession.get(sessionId);
     return lastCozeContext || {};
 }
+function resetRuntimeState() {
+    lastUserChannelId = undefined;
+    lastUserTraceContext = undefined;
+    lastOpenclawSessionId = undefined;
+    cozeContextBySession.clear();
+    lastCozeContext = undefined;
+    activeAgentCtx = undefined;
+    activeAgentChannelId = undefined;
+    activeAgentContextByKey.clear();
+    lastUserInput = undefined;
+    lastUserContextByKey.clear();
+    pendingToolCallsByKey.clear();
+}
 // Active agent context: set in before_agent_start, cleared in agent_end.
 // All hooks between these two (llm_input, llm_output, tool calls, messages)
 // 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",
@@ -497,6 +516,7 @@ const cozeloopTracePlugin = {
     version: PLUGIN_VERSION,
     description: "Report OpenClaw execution traces to CozeLoop via OpenTelemetry",
     activate(api) {
+        resetRuntimeState();
         const pluginConfig = api.pluginConfig || {};
         const authorization = pluginConfig.authorization;
         const workspaceId = pluginConfig.workspaceId;
@@ -505,7 +525,7 @@ const cozeloopTracePlugin = {
             return;
         }
         const config = {
-            endpoint: pluginConfig.endpoint || "https://api.coze.cn/v1/loop/opentelemetry",
+            endpoint: pluginConfig.endpoint || "https://api.coze.cn",
             authorization,
             workspaceId,
             serviceName: pluginConfig.serviceName || "openclaw-agent",
@@ -558,6 +578,30 @@ 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 canFallbackToActiveAgentContext = (rawChannelId) => {
+            const rawSessionId = sessionIdFromChannelId(rawChannelId);
+            const activeSessionId = activeAgentCtx?.openclawSessionId || sessionIdFromChannelId(activeAgentChannelId);
+            return !rawSessionId || !activeSessionId || rawSessionId === activeSessionId;
+        };
+        const canUseLastUserFallbackFor = (ctx, rawChannelId) => {
+            if (!lastUserTraceContext || lastUserTraceContext === ctx)
+                return true;
+            const rawSessionId = ctx?.openclawSessionId || sessionIdFromChannelId(rawChannelId);
+            const lastSessionId = lastUserTraceContext.openclawSessionId || sessionIdFromChannelId(lastUserChannelId);
+            return !rawSessionId || !lastSessionId || rawSessionId === lastSessionId;
+        };
+        const lastUserFallbackFor = (ctx, rawChannelId) => {
+            return canUseLastUserFallbackFor(ctx, rawChannelId) ? lastUserTraceContext : undefined;
+        };
         const startTurn = (runId, channelId, originalChannelId, openclawSessionId) => {
             const traceId = generateId(32);
             const ctx = {
@@ -583,7 +627,7 @@ const cozeloopTracePlugin = {
         const getOrCreateContext = (rawChannelId, runId, hookName) => {
             let channelId = rawChannelId;
             let activeCtx = getContextByChannel(rawChannelId);
-            const effectiveRunId = runId || activeCtx?.runId || `run-${Date.now()}`;
+            const effectiveRunId = runId || activeCtx?.runId || `run-${Date.now()}-${generateId(8)}`;
             if (rawChannelId.startsWith("agent/") && effectiveRunId) {
                 const originalChannelId = getOriginalChannelId(effectiveRunId);
                 if (originalChannelId) {
@@ -594,7 +638,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 +660,140 @@ 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) {
+                if (canFallbackToLastUserContext(channelId)) {
+                    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) {
+                if (canFallbackToActiveAgentContext(channelId)) {
+                    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 +1043,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 +1057,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 +1083,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 +1110,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 +1135,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 +1205,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 +1299,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 +1353,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) {
@@ -1194,14 +1371,15 @@ const cozeloopTracePlugin = {
             }
             const rootSpanId = ctx.rootSpanId;
             const rootSpanStartTime = ctx.rootSpanStartTime;
-            const userInput = ctx.userInput || (lastUserTraceContext ? lastUserTraceContext.userInput : undefined) || lastUserInput;
+            const lastUserFallback = lastUserFallbackFor(ctx, channelId);
+            const userInput = ctx.userInput || lastUserFallback?.userInput || (lastUserFallback ? lastUserInput : undefined);
             const traceId = ctx.traceId;
             const hasRootSpan = !!rootSpanStartTime;
             const savedLastUserChannelId = lastUserChannelId;
             const originalChannelId = ctx.originalChannelId || channelId;
             setTimeout(async () => {
                 if (hasRootSpan) {
-                    const finalOutput = ctx.lastOutput || (lastUserTraceContext ? lastUserTraceContext.lastOutput : undefined);
+                    const finalOutput = ctx.lastOutput || lastUserFallback?.lastOutput;
                     if (config.debug) {
                         api.logger.info(`[CozeloopTrace] Ending root span with input=${userInput ? 'present' : 'missing'}, output=${finalOutput ? 'present' : 'missing'}`);
                     }
@@ -1215,20 +1393,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 丢弃。
@@ -1249,8 +1424,9 @@ const cozeloopTracePlugin = {
         // currentRootContext is set and the agent span becomes a proper child.
         const ensureRootSpan = async (ctx, channelId) => {
             // 心跳轮询消息：不是真实对话，整条 trace 不上报（沿用下方“无 coze-context 即 return”的同款范式）。
+            const lastUserFallback = lastUserFallbackFor(ctx, channelId);
             const heartbeatInput = ctx.userInput
-                || lastUserTraceContext?.userInput || lastUserInput;
+                || lastUserFallback?.userInput || (lastUserFallback ? lastUserInput : undefined);
             if (isHeartbeatInput(heartbeatInput)) {
                 if (config.debug) {
                     api.logger.info(`[CozeloopTrace] skip heartbeat poll trace, traceId=${ctx.traceId}`);
@@ -1267,7 +1443,7 @@ const cozeloopTracePlugin = {
             let cozeCtx = resolveCozeContext(ctx.userInput, ocSessionId);
             if (Object.keys(cozeCtx).length === 0) {
                 // Try the fallback user inputs too before giving up.
-                const fallbackInput = lastUserTraceContext?.userInput || lastUserInput;
+                const fallbackInput = lastUserFallback?.userInput || (lastUserFallback ? lastUserInput : undefined);
                 cozeCtx = resolveCozeContext(fallbackInput, ocSessionId);
             }
             if (Object.keys(cozeCtx).length === 0) {
@@ -1298,7 +1474,7 @@ const cozeloopTracePlugin = {
             // Resolve user input: prefer ctx.userInput set by this turn's
             // message_received, fall back to lastUserTraceContext, then lastUserInput.
             if (!ctx.userInput) {
-                ctx.userInput = lastUserTraceContext?.userInput || lastUserInput;
+                ctx.userInput = lastUserFallback?.userInput || (lastUserFallback ? lastUserInput : undefined);
             }
             const rootSpanData = {
                 name: "openclaw_request",
@@ -1322,9 +1498,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 +1525,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 +1545,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 +1555,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 +1575,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.16",
   "description": "Report OpenClaw execution traces to CozeLoop via OpenTelemetry",
   "type": "plugin",
   "entry": "./dist/index.js",
@@ -10,8 +10,8 @@
     "properties": {
       "endpoint": {
         "type": "string",
-        "default": "https://api.coze.cn/v1/loop/opentelemetry",
-        "description": "CozeLoop OTLP endpoint URL"
+        "default": "https://api.coze.cn",
+        "description": "CozeLoop API base URL"
       },
       "authorization": {
         "type": "string",

package/scripts/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cozeloop/openclaw-cozeloop-trace",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "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"