coze_lab 0.1.31 → 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.31",
+  "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

@@ -80,125 +80,150 @@ async function getRefreshedToken(currentAuthorization, opts = {}) {
 
 const EXPORT_SUCCESS = 0;
 const EXPORT_FAILED = 1;
+const INGEST_TRACE_PATH = "/v1/loop/traces/ingest";
 
-function normalizeTraceUrl(endpoint) {
+function normalizeApiBaseUrl(endpoint) {
     const base = String(endpoint || "").replace(/\/+$/, "");
-    return base.endsWith("/v1/traces") ? base : `${base}/v1/traces`;
+    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 hrTimeToUnixNano(time) {
+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 (BigInt(time[0]) * 1000000000n + BigInt(time[1])).toString();
+        return Number(BigInt(time[0]) * 1000000n + BigInt(Math.trunc(time[1] / 1000)));
     }
     const millis = time instanceof Date ? time.getTime() : Number(time || Date.now());
-    return (BigInt(Math.trunc(millis)) * 1000000n).toString();
+    return Math.trunc(millis * 1000);
 }
 
-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 hrDurationToMicros(duration) {
+    if (Array.isArray(duration)) {
+        return Number(BigInt(duration[0]) * 1000000n + BigInt(Math.trunc(duration[1] / 1000)));
     }
+    return 0;
 }
 
-function scalarToAnyValue(value) {
+function safeStringify(value) {
     if (value === undefined || value === null)
-        return undefined;
+        return "";
     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 };
-    }
+        return value;
     try {
-        return { stringValue: JSON.stringify(value) };
+        return JSON.stringify(value);
     }
     catch {
-        return { stringValue: String(value) };
+        return String(value);
     }
 }
 
-function valueToAnyValue(value) {
-    if (Array.isArray(value)) {
-        const values = value.map(scalarToAnyValue).filter(Boolean);
-        return { arrayValue: { values } };
+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";
     }
-    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 });
-        }
+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;
     }
-    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 (typeof value === "boolean") {
+        maps.bool[key] = value;
+    }
+    else if (typeof value === "number" && Number.isInteger(value)) {
+        maps.long[key] = value;
     }
-    if (span.status?.message) {
-        otlpSpan.status.message = span.status.message;
+    else if (typeof value === "number") {
+        maps.double[key] = value;
+    }
+    else {
+        maps.string[key] = typeof value === "string" ? value : safeStringify(value);
     }
-    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);
+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;
         }
-        scopeGroup.spans.push(spanToOtlp(span));
+        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 {
-        resourceSpans: Array.from(resourceGroups.values()).map((resourceGroup) => ({
-            resource: resourceGroup.resource,
-            scopeSpans: Array.from(resourceGroup.scopeGroups.values()),
-        })),
+        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,
     };
 }
 
@@ -224,17 +249,19 @@ function postJson(url, body, headers) {
             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.setTimeout(15000, () => req.destroy(new Error("CozeLoop ingest export timed out")));
         req.write(data);
         req.end();
     });
 }
 
-class JsonOtlpTraceExporter {
+class CozeloopIngestExporter {
     constructor(config) {
-        this.url = normalizeTraceUrl(config.url);
+        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) {
@@ -245,17 +272,35 @@ class JsonOtlpTraceExporter {
         this.postSpans(spans)
             .then(() => resultCallback({ code: EXPORT_SUCCESS }))
             .catch((err) => {
-                this.logger?.error?.(`[CozeloopTrace] OTLP JSON export failed: ${err?.message || err}`);
+                this.logger?.error?.(`[CozeloopTrace] CozeLoop ingest export failed: ${err?.message || err}`);
                 resultCallback({ code: EXPORT_FAILED, error: err });
             });
     }
     async postSpans(spans) {
-        const body = buildOtlpTraceRequest(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;
@@ -360,12 +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 JsonOtlpTraceExporter({
-            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",
             },

package/scripts/openclaw/dist/index.js

@@ -476,6 +476,19 @@ 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.
@@ -503,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;
@@ -511,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",
@@ -573,6 +587,21 @@ const cozeloopTracePlugin = {
             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 = {
@@ -598,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) {
@@ -656,7 +685,9 @@ const cozeloopTracePlugin = {
                     return found;
             }
             if (lastUserTraceContext) {
-                return { ctx: lastUserTraceContext, channelId: lastUserChannelId || channelId };
+                if (canFallbackToLastUserContext(channelId)) {
+                    return { ctx: lastUserTraceContext, channelId: lastUserChannelId || channelId };
+                }
             }
             return undefined;
         };
@@ -674,7 +705,9 @@ const cozeloopTracePlugin = {
                     return found;
             }
             if (activeAgentCtx) {
-                return { ctx: activeAgentCtx, channelId: activeAgentChannelId || channelId };
+                if (canFallbackToActiveAgentContext(channelId)) {
+                    return { ctx: activeAgentCtx, channelId: activeAgentChannelId || channelId };
+                }
             }
             return undefined;
         };
@@ -1338,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'}`);
                     }
@@ -1390,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}`);
@@ -1408,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) {
@@ -1439,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",

package/scripts/openclaw/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cozeloop-trace",
   "name": "OpenClaw CozeLoop Trace",
-  "version": "0.1.15",
+  "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.15",
+  "version": "0.1.16",
   "description": "OpenClaw Plugin for reporting traces to CozeLoop via OpenTelemetry",
   "type": "module",
   "main": "dist/index.js",