npm - @openclaw/diagnostics-otel - Versions diffs - 2026.7.2-beta.5 → 2026.8.1-beta.2 - Mend

@openclaw/diagnostics-otel 2026.7.2-beta.5 → 2026.8.1-beta.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6110) hide show

package/dist/runtime-api-Cxmw9wkt.js DELETED Viewed

@@ -1,2776 +0,0 @@
-import { isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, redactSensitiveText } from "./api.js";
-import { SpanKind, SpanStatusCode, TraceFlags, context, metrics, trace } from "@opentelemetry/api";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { BatchSpanProcessor, ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
-import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { registerUnhandledRejectionHandler } from "openclaw/plugin-sdk/runtime-env";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { waitForDiagnosticEventsDrained } from "openclaw/plugin-sdk/diagnostic-runtime";
-import { readFileSync } from "node:fs";
-import nodePath from "node:path";
-import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
-import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
-import { ATTR_GEN_AI_INPUT_MESSAGES, ATTR_GEN_AI_OUTPUT_MESSAGES, ATTR_GEN_AI_SYSTEM_INSTRUCTIONS, ATTR_GEN_AI_TOOL_CALL_ARGUMENTS, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_CALL_RESULT, ATTR_GEN_AI_TOOL_DEFINITIONS, GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL, GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT } from "@opentelemetry/semantic-conventions/incubating";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-const DROPPED_OTEL_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
-	"openclaw.callId",
-	"openclaw.call_id",
-	"openclaw.chatId",
-	"openclaw.chat_id",
-	"openclaw.messageId",
-	"openclaw.message_id",
-	"openclaw.parentSpanId",
-	"openclaw.parent_span_id",
-	"openclaw.runId",
-	"openclaw.run_id",
-	"openclaw.sessionId",
-	"openclaw.session_id",
-	"openclaw.sessionKey",
-	"openclaw.session_key",
-	"openclaw.spanId",
-	"openclaw.span_id",
-	"openclaw.toolCallId",
-	"openclaw.tool_call_id",
-	"openclaw.traceId",
-	"openclaw.trace_id"
-]);
-const LOW_CARDINALITY_VALUE_RE = /^[A-Za-z0-9_.:-]{1,120}$/u;
-const SECURITY_TARGET_NAME_VALUE_RE = /^[A-Za-z0-9@/_.:-]{1,256}$/u;
-const MAX_OTEL_LOG_BODY_CHARS = 4 * 1024;
-const MAX_OTEL_LOG_ATTRIBUTE_VALUE_CHARS = 4 * 1024;
-const OTEL_LOG_RAW_ATTRIBUTE_KEY_RE = /^[A-Za-z0-9_.:-]{1,64}$/u;
-const OTEL_LOG_ATTRIBUTE_KEY_RE = /^[A-Za-z0-9_.:-]{1,96}$/u;
-const BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"prototype",
-	"constructor"
-]);
-const OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
-const OTEL_EXPORTER_OTLP_METRICS_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT";
-const OTEL_EXPORTER_OTLP_LOGS_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT";
-const OTEL_EXPORTER_OTLP_CERTIFICATE_ENV = "OTEL_EXPORTER_OTLP_CERTIFICATE";
-const OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_ENV = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE";
-const OTEL_EXPORTER_OTLP_CLIENT_KEY_ENV = "OTEL_EXPORTER_OTLP_CLIENT_KEY";
-const OTEL_SEMCONV_STABILITY_OPT_IN_ENV = "OTEL_SEMCONV_STABILITY_OPT_IN";
-const GEN_AI_LATEST_EXPERIMENTAL_OPT_IN = "gen_ai_latest_experimental";
-const GEN_AI_TOKEN_USAGE_BUCKETS = [
-	1,
-	4,
-	16,
-	64,
-	256,
-	1024,
-	4096,
-	16384,
-	65536,
-	262144,
-	1048576,
-	4194304,
-	16777216,
-	67108864
-];
-const GEN_AI_OPERATION_DURATION_BUCKETS = [
-	.01,
-	.02,
-	.04,
-	.08,
-	.16,
-	.32,
-	.64,
-	1.28,
-	2.56,
-	5.12,
-	10.24,
-	20.48,
-	40.96,
-	81.92
-];
-const OTEL_DEFAULT_HISTOGRAM_BUCKETS = [
-	0,
-	5,
-	10,
-	25,
-	50,
-	75,
-	100,
-	250,
-	500,
-	750,
-	1e3,
-	2500,
-	5e3,
-	7500,
-	1e4
-];
-const AGENT_DURATION_MS_BUCKETS = [
-	...OTEL_DEFAULT_HISTOGRAM_BUCKETS,
-	15e3,
-	2e4,
-	3e4,
-	45e3,
-	6e4,
-	12e4,
-	18e4,
-	24e4,
-	3e5,
-	6e5,
-	9e5,
-	18e5,
-	36e5
-];
-const CONTEXT_TOKENS_BUCKETS = [
-	...OTEL_DEFAULT_HISTOGRAM_BUCKETS,
-	16e3,
-	32e3,
-	64e3,
-	128e3,
-	2e5,
-	4e5,
-	1e6,
-	2e6
-];
-const MAX_RETAINED_TRUSTED_SPAN_CONTEXTS = 1024;
-const RETAINED_TRUSTED_SPAN_CONTEXT_TIMEOUT_MS = 5e3;
-//#endregion
-//#region extensions/diagnostics-otel/src/service-content-normalization.ts
-const MAX_OTEL_CONTENT_ATTRIBUTE_CHARS = 128 * 1024;
-const MAX_OTEL_ERROR_MESSAGE_CHARS = 4 * 1024;
-const PRELOADED_OTEL_SDK_ENV = "OPENCLAW_OTEL_PRELOADED";
-const NO_CONTENT_CAPTURE = {
-	inputMessages: false,
-	outputMessages: false,
-	toolInputs: false,
-	toolOutputs: false,
-	systemPrompt: false,
-	toolDefinitions: false,
-	logBodies: false
-};
-function clampOtelLogText(value, maxChars) {
-	return value.length > maxChars ? `${truncateUtf16Safe(value, maxChars)}...(truncated)` : value;
-}
-function normalizeOtelLogString(value, maxChars) {
-	return clampOtelLogText(redactSensitiveText(value), maxChars);
-}
-function normalizeOtelErrorMessage(value) {
-	if (!value) return;
-	return normalizeOtelLogString(value.trim(), MAX_OTEL_ERROR_MESSAGE_CHARS) || void 0;
-}
-function resolveContentCapturePolicy(value) {
-	return value === true ? {
-		inputMessages: true,
-		outputMessages: true,
-		toolInputs: true,
-		toolOutputs: true,
-		systemPrompt: false,
-		toolDefinitions: true,
-		logBodies: true
-	} : NO_CONTENT_CAPTURE;
-}
-function hasPreloadedOtelSdk() {
-	return process.env[PRELOADED_OTEL_SDK_ENV] === "1";
-}
-function normalizeOtelContentValue(value) {
-	if (typeof value === "string") return normalizeOtelLogString(value, MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
-	if (Array.isArray(value)) {
-		const items = [];
-		for (const item of value.slice(0, 200)) if (typeof item === "string") items.push(item);
-		if (items.length > 0) return normalizeOtelLogString(items.join("\n"), MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
-	}
-	const json = safeJsonString(value, MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
-	if (json) return json;
-}
-const TRUNCATED_JSON_TEXT_SUFFIX = "...(truncated)";
-const JSON_TRUNCATION_STRING_BUDGETS = [
-	8192,
-	4096,
-	2048,
-	1024,
-	512,
-	256,
-	128,
-	64,
-	32
-];
-const JSON_TRUNCATION_ARRAY_ITEM_BUDGETS = [
-	200,
-	100,
-	50,
-	25,
-	10,
-	5,
-	1
-];
-const JSON_TRUNCATION_MAX_OBJECT_FIELDS = 64;
-const JSON_TRUNCATION_MAX_DEPTH = 8;
-function safeJsonString(value, maxChars) {
-	if (value === void 0 || typeof value === "function" || typeof value === "symbol") return;
-	const exact = stringifyJsonForOtelAttribute(value);
-	if (exact && exact.length <= maxChars) return exact;
-	for (const maxArrayItems of JSON_TRUNCATION_ARRAY_ITEM_BUDGETS) for (const maxStringChars of JSON_TRUNCATION_STRING_BUDGETS) {
-		const json = stringifyJsonForOtelAttribute(truncateJsonValueForOtelAttribute(value, {
-			maxArrayItems,
-			maxDepth: JSON_TRUNCATION_MAX_DEPTH,
-			maxObjectFields: JSON_TRUNCATION_MAX_OBJECT_FIELDS,
-			maxStringChars,
-			seen: /* @__PURE__ */ new WeakSet()
-		}));
-		if (json && json.length <= maxChars) return json;
-	}
-	const summary = stringifyJsonForOtelAttribute({
-		truncated: true,
-		reason: exact ? "max_attribute_size" : "unserializable_value",
-		type: describeJsonValue(value)
-	});
-	return summary && summary.length <= maxChars ? summary : void 0;
-}
-function stringifyJsonForOtelAttribute(value) {
-	try {
-		const json = JSON.stringify(value);
-		if (!json) return;
-		return redactSensitiveText(json);
-	} catch {
-		return;
-	}
-}
-function truncateJsonValueForOtelAttribute(value, options) {
-	if (typeof value === "string") return truncateJsonTextForOtelAttribute(value, options.maxStringChars);
-	if (typeof value === "number" || typeof value === "boolean" || value === null) return value;
-	if (typeof value === "bigint") return truncateJsonTextForOtelAttribute(String(value), options.maxStringChars);
-	if (value === void 0 || typeof value === "function" || typeof value === "symbol") return;
-	if (options.maxDepth <= 0) return {
-		truncated: true,
-		reason: "max_depth"
-	};
-	if (Array.isArray(value)) return truncateJsonArrayForOtelAttribute(value, options);
-	if (typeof value === "object") return truncateJsonObjectForOtelAttribute(value, options);
-}
-function truncateJsonArrayForOtelAttribute(value, options) {
-	if (options.seen.has(value)) return [{
-		truncated: true,
-		reason: "circular_reference"
-	}];
-	options.seen.add(value);
-	const nextOptions = {
-		...options,
-		maxDepth: options.maxDepth - 1
-	};
-	const items = value.slice(0, options.maxArrayItems).map((item) => truncateJsonValueForOtelAttribute(item, nextOptions));
-	if (value.length > items.length) items.push({
-		truncated: true,
-		omittedItems: value.length - items.length
-	});
-	options.seen.delete(value);
-	return items;
-}
-function truncateJsonObjectForOtelAttribute(value, options) {
-	if (options.seen.has(value)) return {
-		truncated: true,
-		reason: "circular_reference"
-	};
-	options.seen.add(value);
-	const nextOptions = {
-		...options,
-		maxDepth: options.maxDepth - 1
-	};
-	const result = {};
-	const entries = Object.entries(value).filter(([, field]) => field !== void 0 && typeof field !== "function" && typeof field !== "symbol");
-	for (const [key, field] of entries.slice(0, options.maxObjectFields)) result[key] = truncateJsonValueForOtelAttribute(field, nextOptions);
-	if (entries.length > options.maxObjectFields) {
-		result.truncated = true;
-		result.omittedFields = entries.length - options.maxObjectFields;
-	}
-	options.seen.delete(value);
-	return result;
-}
-function truncateJsonTextForOtelAttribute(value, maxChars) {
-	const redacted = redactSensitiveText(value);
-	if (redacted.length <= maxChars) return redacted;
-	const suffixBudget = Math.min(14, maxChars);
-	return `${truncateUtf16Safe(redacted, Math.max(0, maxChars - suffixBudget))}${TRUNCATED_JSON_TEXT_SUFFIX.slice(14 - suffixBudget)}`;
-}
-function describeJsonValue(value) {
-	if (Array.isArray(value)) return "array";
-	if (value === null) return "null";
-	return typeof value;
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-attributes.ts
-function redactOtelAttributes(attributes) {
-	const redactedAttributes = {};
-	for (const [key, value] of Object.entries(attributes)) {
-		if (DROPPED_OTEL_ATTRIBUTE_KEYS.has(key)) continue;
-		redactedAttributes[key] = typeof value === "string" ? redactSensitiveText(value) : value;
-	}
-	return redactedAttributes;
-}
-function lowCardinalityAttr(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	const redactedLower = redacted.toLowerCase();
-	if (redactedLower.startsWith("agent:") || redactedLower.includes(":agent:")) return fallback;
-	return LOW_CARDINALITY_VALUE_RE.test(redacted) ? redacted : fallback;
-}
-function securityTargetNameAttr(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	const redactedLower = redacted.toLowerCase();
-	if (redactedLower.startsWith("agent:") || redactedLower.includes(":agent:")) return fallback;
-	return SECURITY_TARGET_NAME_VALUE_RE.test(redacted) ? redacted : fallback;
-}
-function lowCardinalityQueueLaneAttr(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	if (redacted.toLowerCase().startsWith("agent:")) return fallback;
-	const scopedLaneIndex = redacted.indexOf(":");
-	const lane = scopedLaneIndex >= 0 ? redacted.slice(0, scopedLaneIndex) : redacted;
-	return LOW_CARDINALITY_VALUE_RE.test(lane) ? lane : fallback;
-}
-function shouldCaptureOtelLogBody(policy) {
-	return policy.logBodies;
-}
-function otelLogTimestampIso(timestamp) {
-	if (timestamp instanceof Date) return timestamp.toISOString();
-	if (typeof timestamp === "number" && Number.isFinite(timestamp)) return new Date(timestamp).toISOString();
-	if (Array.isArray(timestamp)) {
-		const [seconds, nanoseconds] = timestamp;
-		if (Number.isFinite(seconds) && Number.isFinite(nanoseconds)) return new Date(seconds * 1e3 + Math.trunc(nanoseconds / 1e6)).toISOString();
-	}
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
-function writeStdoutDiagnosticLogRecord(params) {
-	const { logRecord, serviceName, traceContext } = params;
-	const line = {
-		ts: otelLogTimestampIso(logRecord.timestamp),
-		signal: "openclaw.diagnostic.log",
-		"service.name": serviceName,
-		severityText: logRecord.severityText,
-		severityNumber: logRecord.severityNumber,
-		body: logRecord.body,
-		attributes: logRecord.attributes ?? {},
-		...traceContext?.traceId ? { trace_id: traceContext.traceId } : {},
-		...traceContext?.spanId ? { span_id: traceContext.spanId } : {},
-		...traceContext?.traceFlags ? { trace_flags: traceContext.traceFlags } : {}
-	};
-	process.stdout.write(`${JSON.stringify(line)}\n`);
-}
-function assignOtelLogAttribute(attributes, key, value) {
-	if (Object.keys(attributes).length >= 64) return;
-	if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key)) return;
-	if (redactSensitiveText(key) !== key) return;
-	if (!OTEL_LOG_ATTRIBUTE_KEY_RE.test(key)) return;
-	if (typeof value === "string") {
-		attributes[key] = normalizeOtelLogString(value, MAX_OTEL_LOG_ATTRIBUTE_VALUE_CHARS);
-		return;
-	}
-	if (typeof value === "number" && Number.isFinite(value)) {
-		attributes[key] = value;
-		return;
-	}
-	if (typeof value === "boolean") attributes[key] = value;
-}
-function assignOtelLogEventAttributes(attributes, eventAttributes) {
-	if (!eventAttributes) return;
-	for (const [rawKey, value] of Object.entries(eventAttributes)) {
-		if (Object.keys(attributes).length >= 64) break;
-		const key = rawKey.trim();
-		if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key)) continue;
-		if (redactSensitiveText(key) !== key) continue;
-		if (!OTEL_LOG_RAW_ATTRIBUTE_KEY_RE.test(key)) continue;
-		assignOtelLogAttribute(attributes, `openclaw.${key}`, value);
-	}
-}
-function assignOtelSecurityEventAttributes(attributes, eventAttributes) {
-	if (!eventAttributes) return;
-	for (const [rawKey, value] of Object.entries(eventAttributes)) {
-		if (Object.keys(attributes).length >= 64) break;
-		const key = rawKey.trim();
-		if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key)) continue;
-		if (redactSensitiveText(key) !== key) continue;
-		if (!OTEL_LOG_RAW_ATTRIBUTE_KEY_RE.test(key)) continue;
-		assignOtelLogAttribute(attributes, `openclaw.security.attribute.${key}`, typeof value === "string" ? lowCardinalityAttr(value) : value);
-	}
-}
-function securitySeverityText(severity) {
-	switch (severity) {
-		case "critical": return "FATAL";
-		case "high": return "ERROR";
-		case "medium": return "WARN";
-		case "info":
-		case "low": return "INFO";
-	}
-	return severity;
-}
-function assignOtelSecurityAttributes(attributes, evt) {
-	assignOtelLogAttribute(attributes, "openclaw.security.event_id", evt.eventId);
-	assignOtelLogAttribute(attributes, "openclaw.security.category", evt.category);
-	assignOtelLogAttribute(attributes, "openclaw.security.action", lowCardinalityAttr(evt.action));
-	assignOtelLogAttribute(attributes, "openclaw.security.outcome", evt.outcome);
-	assignOtelLogAttribute(attributes, "openclaw.security.severity", evt.severity);
-	if (evt.reason) assignOtelLogAttribute(attributes, "openclaw.security.reason", lowCardinalityAttr(evt.reason));
-	if (evt.actor) {
-		assignOtelLogAttribute(attributes, "openclaw.security.actor.kind", evt.actor.kind);
-		if (evt.actor.idHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.id_hash", lowCardinalityAttr(evt.actor.idHash));
-		if (evt.actor.deviceIdHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.device_id_hash", lowCardinalityAttr(evt.actor.deviceIdHash));
-		if (evt.actor.channel) assignOtelLogAttribute(attributes, "openclaw.security.actor.channel", lowCardinalityAttr(evt.actor.channel));
-		if (evt.actor.role) assignOtelLogAttribute(attributes, "openclaw.security.actor.role", lowCardinalityAttr(evt.actor.role));
-		if (evt.actor.scopes?.length) assignOtelLogAttribute(attributes, "openclaw.security.actor.scopes", evt.actor.scopes.map((scope) => lowCardinalityAttr(scope)).join(","));
-	}
-	if (evt.target) {
-		assignOtelLogAttribute(attributes, "openclaw.security.target.kind", evt.target.kind);
-		if (evt.target.idHash) assignOtelLogAttribute(attributes, "openclaw.security.target.id_hash", lowCardinalityAttr(evt.target.idHash));
-		if (evt.target.name) assignOtelLogAttribute(attributes, "openclaw.security.target.name", securityTargetNameAttr(evt.target.name));
-		if (evt.target.owner) assignOtelLogAttribute(attributes, "openclaw.security.target.owner", lowCardinalityAttr(evt.target.owner));
-	}
-	if (evt.policy) {
-		if (evt.policy.id) assignOtelLogAttribute(attributes, "openclaw.security.policy.id", lowCardinalityAttr(evt.policy.id));
-		if (evt.policy.decision) assignOtelLogAttribute(attributes, "openclaw.security.policy.decision", evt.policy.decision);
-		if (evt.policy.reason) assignOtelLogAttribute(attributes, "openclaw.security.policy.reason", lowCardinalityAttr(evt.policy.reason));
-	}
-	if (evt.control) {
-		if (evt.control.id) assignOtelLogAttribute(attributes, "openclaw.security.control.id", lowCardinalityAttr(evt.control.id));
-		if (evt.control.family) assignOtelLogAttribute(attributes, "openclaw.security.control.family", evt.control.family);
-	}
-	assignOtelSecurityEventAttributes(attributes, evt.attributes);
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-exporter.ts
-function normalizeEndpoint(endpoint) {
-	const trimmed = endpoint?.trim();
-	return trimmed ? trimmed.replace(/\/+$/, "") : void 0;
-}
-function resolveOtelUrl(endpoint, path) {
-	if (!endpoint) return;
-	const endpointWithoutQueryOrFragment = endpoint.split(/[?#]/, 1)[0] ?? endpoint;
-	if (/\/v1\/(?:traces|metrics|logs)$/i.test(endpointWithoutQueryOrFragment)) return endpoint;
-	if (/[?#]/u.test(endpoint)) try {
-		const url = new URL(endpoint);
-		url.pathname = `${url.pathname.replace(/\/+$/u, "")}/${path}`;
-		return url.toString();
-	} catch {}
-	return `${endpoint}/${path}`;
-}
-function resolveSignalOtelUrl(params) {
-	return resolveOtelUrl(normalizeEndpoint(params.signalEndpoint ?? params.signalEnvEndpoint) ?? params.endpoint, params.path);
-}
-function readOtelEnvFile(params) {
-	const signalEnvName = `OTEL_EXPORTER_OTLP_${params.signalIdentifier}_${params.signalSuffix}`;
-	const filePath = normalizeOtelEnvValue(process.env[signalEnvName]) ?? normalizeOtelEnvValue(process.env[params.sharedEnvName]);
-	if (!filePath) return;
-	try {
-		return readFileSync(nodePath.resolve(process.cwd(), filePath));
-	} catch {
-		params.logger.warn(`diagnostics-otel: ${params.warning}`);
-		return;
-	}
-}
-function normalizeOtelEnvValue(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
-}
-function resolveOtelHttpAgentOptions(params) {
-	const { url, signalIdentifier, logger } = params;
-	if (!url) return;
-	const ca = readOtelEnvFile({
-		signalIdentifier,
-		signalSuffix: "CERTIFICATE",
-		sharedEnvName: OTEL_EXPORTER_OTLP_CERTIFICATE_ENV,
-		logger,
-		warning: "failed to read root certificate file"
-	});
-	const cert = readOtelEnvFile({
-		signalIdentifier,
-		signalSuffix: "CLIENT_CERTIFICATE",
-		sharedEnvName: OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_ENV,
-		logger,
-		warning: "failed to read client certificate chain file"
-	});
-	const key = readOtelEnvFile({
-		signalIdentifier,
-		signalSuffix: "CLIENT_KEY",
-		sharedEnvName: OTEL_EXPORTER_OTLP_CLIENT_KEY_ENV,
-		logger,
-		warning: "failed to read client certificate private key file"
-	});
-	const agentOptions = {
-		keepAlive: true,
-		...ca !== void 0 ? { ca } : {},
-		...cert !== void 0 ? { cert } : {},
-		...key !== void 0 ? { key } : {}
-	};
-	try {
-		const agent = createNodeProxyAgent({
-			mode: "env",
-			targetUrl: url,
-			agentOptions
-		});
-		return agent ? () => agent : void 0;
-	} catch {
-		logger.warn(`diagnostics-otel: env proxy agent unavailable for OTLP ${signalIdentifier.toLowerCase()} exporter; falling back to default Node agent`);
-		return;
-	}
-}
-function resolveSampleRate(value) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return;
-	if (value < 0 || value > 1) return;
-	return value;
-}
-function formatError(err) {
-	if (err instanceof Error) return err.stack ?? err.message;
-	if (typeof err === "string") return err;
-	try {
-		return JSON.stringify(err);
-	} catch {
-		return String(err);
-	}
-}
-function errorCategory(err) {
-	try {
-		if (err instanceof Error && typeof err.name === "string" && err.name.trim()) return lowCardinalityAttr(err.name, "Error");
-		return lowCardinalityAttr(typeof err, "unknown");
-	} catch {
-		return "unknown";
-	}
-}
-function collectNestedErrorCandidates(err) {
-	const queue = [err];
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current == null || seen.has(current)) continue;
-		seen.add(current);
-		candidates.push(current);
-		if (Array.isArray(current)) {
-			for (const item of current) if (item != null && !seen.has(item)) queue.push(item);
-			continue;
-		}
-		if (typeof current !== "object") continue;
-		const record = current;
-		for (const nested of [
-			record.cause,
-			record.reason,
-			record.original,
-			record.error
-		]) if (nested != null && !seen.has(nested)) queue.push(nested);
-		if (Array.isArray(record.errors)) {
-			for (const nested of record.errors) if (nested != null && !seen.has(nested)) queue.push(nested);
-		}
-	}
-	return candidates;
-}
-function readErrorName(err) {
-	if (!err || typeof err !== "object") return;
-	const name = err.name;
-	return typeof name === "string" && name.trim() ? name : void 0;
-}
-function readErrorCode(err) {
-	if (!err || typeof err !== "object") return;
-	const code = err.code;
-	return typeof code === "string" || typeof code === "number" ? code : void 0;
-}
-function findOtlpExporterError(reason) {
-	for (const candidate of collectNestedErrorCandidates(reason)) if (readErrorName(candidate) === "OTLPExporterError" && candidate && typeof candidate === "object") return candidate;
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-events.ts
-function createDiagnosticsEventHandler(params) {
-	const { logger, recorders, recordLogRecord, recordSecurityEvent } = params;
-	const { recordModelUsage, recordWebhookReceived, recordWebhookProcessed, recordWebhookError, recordMessageQueued, recordMessageReceived, recordMessageDispatchStarted, recordMessageDispatchCompleted, recordMessageProcessed, recordMessageDeliveryStarted, recordMessageDeliveryCompleted, recordMessageDeliveryError, recordTalkEvent, recordLaneEnqueue, recordLaneDequeue, recordSessionState, recordSessionTurnCreated, recordSessionStuck, recordSessionRecoveryRequested, recordSessionRecoveryCompleted, recordRunAttempt, recordHeartbeat, recordLivenessWarning, recordDiagnosticPhaseCompleted, recordRunStarted, recordRunCompleted, recordHarnessRunStarted, recordHarnessRunCompleted, recordHarnessRunError, recordContextAssembled, recordModelCallStarted, recordModelCallCompleted, recordModelCallError, recordToolExecutionStarted, recordToolExecutionCompleted, recordToolExecutionError, recordToolExecutionBlocked, recordSkillUsed, recordExecProcessCompleted, recordToolLoop, recordMemorySample, recordMemoryPressure, recordAsyncQueueDropped, recordTelemetryExporter, recordPayloadLarge, recordModelFailover } = recorders;
-	return (evt, metadata, privateData) => {
-		try {
-			switch (evt.type) {
-				case "model.usage":
-					recordModelUsage(evt, metadata);
-					return;
-				case "webhook.received":
-					recordWebhookReceived(evt);
-					return;
-				case "webhook.processed":
-					recordWebhookProcessed(evt);
-					return;
-				case "webhook.error":
-					recordWebhookError(evt);
-					return;
-				case "message.queued":
-					recordMessageQueued(evt);
-					return;
-				case "message.received":
-					recordMessageReceived(evt);
-					return;
-				case "message.dispatch.started":
-					recordMessageDispatchStarted(evt, metadata);
-					return;
-				case "message.dispatch.completed":
-					recordMessageDispatchCompleted(evt);
-					return;
-				case "message.processed":
-					recordMessageProcessed(evt, metadata);
-					return;
-				case "message.delivery.started":
-					recordMessageDeliveryStarted(evt);
-					return;
-				case "message.delivery.completed":
-					recordMessageDeliveryCompleted(evt, metadata);
-					return;
-				case "message.delivery.error":
-					recordMessageDeliveryError(evt, metadata);
-					return;
-				case "talk.event":
-					recordTalkEvent(evt, metadata);
-					return;
-				case "queue.lane.enqueue":
-					recordLaneEnqueue(evt);
-					return;
-				case "queue.lane.dequeue":
-					recordLaneDequeue(evt);
-					return;
-				case "session.state":
-					recordSessionState(evt);
-					break;
-				case "session.long_running":
-				case "session.stalled": break;
-				case "session.turn.created":
-					recordSessionTurnCreated(evt);
-					return;
-				case "session.stuck":
-					recordSessionStuck(evt);
-					return;
-				case "session.recovery.requested":
-					recordSessionRecoveryRequested(evt);
-					return;
-				case "session.recovery.completed":
-					recordSessionRecoveryCompleted(evt);
-					return;
-				case "run.attempt":
-					recordRunAttempt(evt);
-					break;
-				case "run.progress": break;
-				case "run.execution_phase": break;
-				case "diagnostic.heartbeat":
-					recordHeartbeat(evt);
-					return;
-				case "diagnostic.liveness.warning":
-					recordLivenessWarning(evt);
-					return;
-				case "diagnostic.phase.completed":
-					recordDiagnosticPhaseCompleted(evt);
-					return;
-				case "run.started":
-					recordRunStarted(evt, metadata);
-					return;
-				case "run.completed":
-					recordRunCompleted(evt, metadata, privateData);
-					return;
-				case "harness.run.started":
-					recordHarnessRunStarted(evt, metadata);
-					return;
-				case "harness.run.completed":
-					recordHarnessRunCompleted(evt, metadata, privateData);
-					return;
-				case "harness.run.error":
-					recordHarnessRunError(evt, metadata, privateData);
-					return;
-				case "context.assembled":
-					recordContextAssembled(evt, metadata);
-					return;
-				case "model.call.started":
-					recordModelCallStarted(evt, metadata);
-					return;
-				case "model.call.completed":
-					recordModelCallCompleted(evt, metadata, privateData.modelContent);
-					return;
-				case "model.call.error":
-					recordModelCallError(evt, metadata, privateData.modelContent);
-					return;
-				case "tool.execution.started":
-					recordToolExecutionStarted(evt, metadata);
-					return;
-				case "tool.execution.completed":
-					recordToolExecutionCompleted(evt, metadata, privateData.toolContent);
-					return;
-				case "tool.execution.error":
-					recordToolExecutionError(evt, metadata, privateData.toolContent);
-					return;
-				case "tool.execution.blocked":
-					recordToolExecutionBlocked(evt, metadata);
-					return;
-				case "skill.used":
-					recordSkillUsed(evt, metadata);
-					return;
-				case "exec.process.completed":
-					recordExecProcessCompleted(evt);
-					break;
-				case "exec.approval.followup_suppressed": break;
-				case "log.record":
-					recordLogRecord?.(evt, metadata);
-					return;
-				case "security.event":
-					recordSecurityEvent?.(evt, metadata);
-					return;
-				case "tool.loop":
-					recordToolLoop(evt);
-					return;
-				case "diagnostic.memory.sample":
-					recordMemorySample(evt);
-					return;
-				case "diagnostic.memory.pressure":
-					recordMemoryPressure(evt);
-					return;
-				case "diagnostic.async_queue.dropped":
-					recordAsyncQueueDropped(evt);
-					return;
-				case "telemetry.exporter":
-					recordTelemetryExporter(evt, metadata);
-					return;
-				case "payload.large":
-					recordPayloadLarge(evt);
-					return;
-				case "model.failover": recordModelFailover(evt, metadata);
-			}
-		} catch (err) {
-			logger.error(`diagnostics-otel: event handler failed (${evt.type}): ${formatError(err)}`);
-		}
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-trace-context.ts
-function normalizeTraceContext(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	const candidate = value;
-	if (!isValidDiagnosticTraceId(candidate.traceId)) return;
-	if (candidate.spanId !== void 0 && !isValidDiagnosticSpanId(candidate.spanId)) return;
-	if (candidate.parentSpanId !== void 0 && !isValidDiagnosticSpanId(candidate.parentSpanId)) return;
-	if (candidate.traceFlags !== void 0 && !isValidDiagnosticTraceFlags(candidate.traceFlags)) return;
-	return {
-		traceId: candidate.traceId,
-		...candidate.spanId ? { spanId: candidate.spanId } : {},
-		...candidate.parentSpanId ? { parentSpanId: candidate.parentSpanId } : {},
-		...candidate.traceFlags ? { traceFlags: candidate.traceFlags } : {}
-	};
-}
-function traceFlagsToOtel(traceFlags) {
-	return (Number.parseInt(traceFlags ?? "00", 16) & TraceFlags.SAMPLED) !== 0 ? TraceFlags.SAMPLED : TraceFlags.NONE;
-}
-function contextForTraceContext(traceContext) {
-	const normalized = normalizeTraceContext(traceContext);
-	if (!normalized?.spanId) return;
-	return trace.setSpanContext(context.active(), {
-		traceId: normalized.traceId,
-		spanId: normalized.spanId,
-		traceFlags: traceFlagsToOtel(normalized.traceFlags),
-		isRemote: true
-	});
-}
-function contextForTrustedTraceContext(evt, metadata) {
-	return metadata.trusted || metadata.trustedTraceContext === true ? contextForTraceContext(evt.trace) : void 0;
-}
-function normalizedTrustedTraceContext(evt, metadata) {
-	return metadata.trusted || metadata.trustedTraceContext === true ? normalizeTraceContext(evt.trace) : void 0;
-}
-function addTraceAttributes(attributes, traceContext) {
-	const normalized = normalizeTraceContext(traceContext);
-	if (!normalized) return;
-	attributes["openclaw.traceId"] = normalized.traceId;
-	if (normalized.spanId) attributes["openclaw.spanId"] = normalized.spanId;
-	if (normalized.parentSpanId) attributes["openclaw.parentSpanId"] = normalized.parentSpanId;
-	if (normalized.traceFlags) attributes["openclaw.traceFlags"] = normalized.traceFlags;
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-logs.ts
-const LOG_SEVERITY_MAP = {
-	TRACE: 1,
-	DEBUG: 5,
-	INFO: 9,
-	WARN: 13,
-	ERROR: 17,
-	FATAL: 21
-};
-function createDiagnosticsLogExporter(params) {
-	const { contentCapturePolicy, emitExporterEvent, flushIntervalMs, headers, logger, logsEnabled, logsToOtlp, logsToStdout, logUrl, resource, serviceName } = params;
-	let logProvider = null;
-	const logSeverityMap = LOG_SEVERITY_MAP;
-	let recordLogRecord;
-	let recordSecurityEvent;
-	if (logsEnabled) {
-		let logRecordExportFailureLastReportedAt = Number.NEGATIVE_INFINITY;
-		let otelLogger;
-		if (logsToOtlp) {
-			const logHttpAgentOptions = resolveOtelHttpAgentOptions({
-				url: logUrl,
-				signalIdentifier: "LOGS",
-				logger
-			});
-			logProvider = new LoggerProvider({
-				resource,
-				processors: [new BatchLogRecordProcessor({
-					exporter: new OTLPLogExporter({
-						...logUrl ? { url: logUrl } : {},
-						...headers ? { headers } : {},
-						...logHttpAgentOptions ? { httpAgentOptions: logHttpAgentOptions } : {}
-					}),
-					...typeof flushIntervalMs === "number" ? { scheduledDelayMillis: Math.max(1e3, flushIntervalMs) } : {}
-				})]
-			});
-			otelLogger = logProvider.getLogger("openclaw");
-		}
-		const reportLogExportFailure = (err, label) => {
-			emitExporterEvent({
-				exporter: "diagnostics-otel",
-				signal: "logs",
-				status: "failure",
-				reason: "emit_failed",
-				errorCategory: errorCategory(err)
-			});
-			const now = Date.now();
-			if (now - logRecordExportFailureLastReportedAt >= 6e4) {
-				logRecordExportFailureLastReportedAt = now;
-				logger.error(`diagnostics-otel: ${label} export failed: ${formatError(err)}`);
-			}
-		};
-		const emitLogRecord = ({ logRecord, traceContext }) => {
-			if (logsToOtlp) otelLogger?.emit(logRecord);
-			if (logsToStdout) writeStdoutDiagnosticLogRecord({
-				logRecord,
-				serviceName,
-				...traceContext ? { traceContext } : {}
-			});
-		};
-		const buildDiagnosticLogRecord = (evt, metadata) => {
-			const logLevelName = evt.level || "INFO";
-			const severityNumber = logSeverityMap[logLevelName] ?? 9;
-			const body = shouldCaptureOtelLogBody(contentCapturePolicy) ? normalizeOtelLogString(evt.message || "log", MAX_OTEL_LOG_BODY_CHARS) : "log";
-			const attributes = Object.create(null);
-			assignOtelLogAttribute(attributes, "openclaw.log.level", logLevelName);
-			if (evt.loggerName) assignOtelLogAttribute(attributes, "openclaw.logger", evt.loggerName);
-			if (evt.loggerParents?.length) assignOtelLogAttribute(attributes, "openclaw.logger.parents", evt.loggerParents.join("."));
-			assignOtelLogEventAttributes(attributes, evt.attributes);
-			if (evt.code?.line) assignOtelLogAttribute(attributes, "code.lineno", evt.code.line);
-			if (evt.code?.functionName) assignOtelLogAttribute(attributes, "code.function", evt.code.functionName);
-			const traceContext = normalizedTrustedTraceContext(evt, metadata);
-			addTraceAttributes(attributes, traceContext);
-			const logRecord = {
-				body,
-				severityText: logLevelName,
-				severityNumber,
-				attributes: redactOtelAttributes(attributes),
-				timestamp: evt.ts
-			};
-			const logContext = contextForTrustedTraceContext(evt, metadata);
-			if (logContext) logRecord.context = logContext;
-			return {
-				logRecord,
-				...traceContext ? { traceContext } : {}
-			};
-		};
-		const buildSecurityLogRecord = (evt, metadata) => {
-			const severityText = securitySeverityText(evt.severity);
-			const attributes = Object.create(null);
-			assignOtelSecurityAttributes(attributes, evt);
-			const traceContext = normalizedTrustedTraceContext(evt, metadata);
-			const logRecord = {
-				body: "openclaw.security.event",
-				severityText,
-				severityNumber: logSeverityMap[severityText] ?? 9,
-				attributes: redactOtelAttributes(attributes),
-				timestamp: evt.ts
-			};
-			const logContext = contextForTrustedTraceContext(evt, metadata);
-			if (logContext) logRecord.context = logContext;
-			return {
-				logRecord,
-				...traceContext ? { traceContext } : {}
-			};
-		};
-		recordLogRecord = (evt, metadata) => {
-			try {
-				emitLogRecord(buildDiagnosticLogRecord(evt, metadata));
-			} catch (err) {
-				reportLogExportFailure(err, "log record");
-			}
-		};
-		recordSecurityEvent = (evt, metadata) => {
-			if (!metadata.trusted) return;
-			try {
-				emitLogRecord(buildSecurityLogRecord(evt, metadata));
-			} catch (err) {
-				reportLogExportFailure(err, "security event");
-			}
-		};
-	}
-	return {
-		logProvider,
-		recordLogRecord,
-		recordSecurityEvent
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-metrics.ts
-function createDiagnosticsMetrics(meter) {
-	return {
-		tokensCounter: meter.createCounter("openclaw.tokens", {
-			unit: "1",
-			description: "Token usage by type"
-		}),
-		genAiTokenUsageHistogram: meter.createHistogram("gen_ai.client.token.usage", {
-			unit: "{token}",
-			description: "Number of input and output tokens used by GenAI client operations",
-			advice: { explicitBucketBoundaries: GEN_AI_TOKEN_USAGE_BUCKETS }
-		}),
-		genAiOperationDurationHistogram: meter.createHistogram("gen_ai.client.operation.duration", {
-			unit: "s",
-			description: "GenAI client operation duration",
-			advice: { explicitBucketBoundaries: GEN_AI_OPERATION_DURATION_BUCKETS }
-		}),
-		costCounter: meter.createCounter("openclaw.cost.usd", {
-			unit: "1",
-			description: "Estimated model cost (USD)"
-		}),
-		durationHistogram: meter.createHistogram("openclaw.run.duration_ms", {
-			unit: "ms",
-			description: "Agent run duration",
-			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
-		}),
-		harnessDurationHistogram: meter.createHistogram("openclaw.harness.duration_ms", {
-			unit: "ms",
-			description: "Agent harness lifecycle duration",
-			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
-		}),
-		contextHistogram: meter.createHistogram("openclaw.context.tokens", {
-			unit: "1",
-			description: "Context window size and usage",
-			advice: { explicitBucketBoundaries: CONTEXT_TOKENS_BUCKETS }
-		}),
-		webhookReceivedCounter: meter.createCounter("openclaw.webhook.received", {
-			unit: "1",
-			description: "Webhook requests received"
-		}),
-		webhookErrorCounter: meter.createCounter("openclaw.webhook.error", {
-			unit: "1",
-			description: "Webhook processing errors"
-		}),
-		webhookDurationHistogram: meter.createHistogram("openclaw.webhook.duration_ms", {
-			unit: "ms",
-			description: "Webhook processing duration"
-		}),
-		messageQueuedCounter: meter.createCounter("openclaw.message.queued", {
-			unit: "1",
-			description: "Messages queued for processing"
-		}),
-		messageReceivedCounter: meter.createCounter("openclaw.message.received", {
-			unit: "1",
-			description: "Inbound messages received"
-		}),
-		messageDispatchStartedCounter: meter.createCounter("openclaw.message.dispatch.started", {
-			unit: "1",
-			description: "Inbound message dispatch attempts started"
-		}),
-		messageDispatchCompletedCounter: meter.createCounter("openclaw.message.dispatch.completed", {
-			unit: "1",
-			description: "Inbound message dispatch attempts completed"
-		}),
-		messageDispatchDurationHistogram: meter.createHistogram("openclaw.message.dispatch.duration_ms", {
-			unit: "ms",
-			description: "Inbound message dispatch duration"
-		}),
-		messageProcessedCounter: meter.createCounter("openclaw.message.processed", {
-			unit: "1",
-			description: "Messages processed by outcome"
-		}),
-		messageDurationHistogram: meter.createHistogram("openclaw.message.duration_ms", {
-			unit: "ms",
-			description: "Message processing duration"
-		}),
-		messageDeliveryStartedCounter: meter.createCounter("openclaw.message.delivery.started", {
-			unit: "1",
-			description: "Outbound message delivery attempts started"
-		}),
-		messageDeliveryDurationHistogram: meter.createHistogram("openclaw.message.delivery.duration_ms", {
-			unit: "ms",
-			description: "Outbound message delivery duration"
-		}),
-		queueDepthHistogram: meter.createHistogram("openclaw.queue.depth", {
-			unit: "1",
-			description: "Queue depth on enqueue/dequeue"
-		}),
-		queueWaitHistogram: meter.createHistogram("openclaw.queue.wait_ms", {
-			unit: "ms",
-			description: "Queue wait time before execution"
-		}),
-		laneEnqueueCounter: meter.createCounter("openclaw.queue.lane.enqueue", {
-			unit: "1",
-			description: "Command queue lane enqueue events"
-		}),
-		laneDequeueCounter: meter.createCounter("openclaw.queue.lane.dequeue", {
-			unit: "1",
-			description: "Command queue lane dequeue events"
-		}),
-		sessionStateCounter: meter.createCounter("openclaw.session.state", {
-			unit: "1",
-			description: "Session state transitions"
-		}),
-		sessionTurnCreatedCounter: meter.createCounter("openclaw.session.turn.created", {
-			unit: "1",
-			description: "Agent session turns created"
-		}),
-		sessionStuckCounter: meter.createCounter("openclaw.session.stuck", {
-			unit: "1",
-			description: "Sessions stuck in processing"
-		}),
-		sessionStuckAgeHistogram: meter.createHistogram("openclaw.session.stuck_age_ms", {
-			unit: "ms",
-			description: "Age of stuck sessions"
-		}),
-		sessionRecoveryRequestedCounter: meter.createCounter("openclaw.session.recovery.requested", {
-			unit: "1",
-			description: "Session recovery attempts requested"
-		}),
-		sessionRecoveryCompletedCounter: meter.createCounter("openclaw.session.recovery.completed", {
-			unit: "1",
-			description: "Session recovery attempts completed"
-		}),
-		sessionRecoveryAgeHistogram: meter.createHistogram("openclaw.session.recovery.age_ms", {
-			unit: "ms",
-			description: "Age of sessions selected for recovery"
-		}),
-		talkEventCounter: meter.createCounter("openclaw.talk.event", {
-			unit: "1",
-			description: "Talk events emitted by type"
-		}),
-		talkEventDurationHistogram: meter.createHistogram("openclaw.talk.event.duration_ms", {
-			unit: "ms",
-			description: "Talk event duration when reported"
-		}),
-		talkAudioBytesHistogram: meter.createHistogram("openclaw.talk.audio.bytes", {
-			unit: "By",
-			description: "Talk audio frame byte lengths"
-		}),
-		runAttemptCounter: meter.createCounter("openclaw.run.attempt", {
-			unit: "1",
-			description: "Run attempts"
-		}),
-		toolLoopCounter: meter.createCounter("openclaw.tool.loop", {
-			unit: "1",
-			description: "Detected repetitive tool-call loop events"
-		}),
-		skillUsedCounter: meter.createCounter("openclaw.skill.used", {
-			unit: "1",
-			description: "Skills used by agent runs"
-		}),
-		modelCallDurationHistogram: meter.createHistogram("openclaw.model_call.duration_ms", {
-			unit: "ms",
-			description: "Model call duration"
-		}),
-		modelCallRequestBytesHistogram: meter.createHistogram("openclaw.model_call.request_bytes", {
-			unit: "By",
-			description: "UTF-8 byte size of sanitized model request payloads"
-		}),
-		modelCallResponseBytesHistogram: meter.createHistogram("openclaw.model_call.response_bytes", {
-			unit: "By",
-			description: "UTF-8 byte size of bounded streamed model response payloads"
-		}),
-		modelCallTimeToFirstByteHistogram: meter.createHistogram("openclaw.model_call.time_to_first_byte_ms", {
-			unit: "ms",
-			description: "Elapsed time before the first streamed model response event"
-		}),
-		modelFailoverCounter: meter.createCounter("openclaw.model.failover", {
-			unit: "1",
-			description: "Model failovers by source, destination, lane, and reason"
-		}),
-		toolExecutionDurationHistogram: meter.createHistogram("openclaw.tool.execution.duration_ms", {
-			unit: "ms",
-			description: "Tool execution duration"
-		}),
-		toolExecutionBlockedCounter: meter.createCounter("openclaw.tool.execution.blocked", {
-			unit: "1",
-			description: "Tool executions blocked by policy or sandbox diagnostics"
-		}),
-		execProcessDurationHistogram: meter.createHistogram("openclaw.exec.duration_ms", {
-			unit: "ms",
-			description: "Exec process duration"
-		}),
-		memoryRssHistogram: meter.createHistogram("openclaw.memory.rss_bytes", {
-			unit: "By",
-			description: "Resident set size reported by diagnostic memory samples"
-		}),
-		memoryHeapUsedHistogram: meter.createHistogram("openclaw.memory.heap_used_bytes", {
-			unit: "By",
-			description: "Heap used bytes reported by diagnostic memory samples"
-		}),
-		memoryHeapTotalHistogram: meter.createHistogram("openclaw.memory.heap_total_bytes", {
-			unit: "By",
-			description: "Heap total bytes reported by diagnostic memory samples"
-		}),
-		memoryExternalHistogram: meter.createHistogram("openclaw.memory.external_bytes", {
-			unit: "By",
-			description: "External memory bytes reported by diagnostic memory samples"
-		}),
-		memoryArrayBuffersHistogram: meter.createHistogram("openclaw.memory.array_buffers_bytes", {
-			unit: "By",
-			description: "ArrayBuffer bytes reported by diagnostic memory samples"
-		}),
-		memoryPressureCounter: meter.createCounter("openclaw.memory.pressure", {
-			unit: "1",
-			description: "Diagnostic memory pressure events"
-		}),
-		asyncQueueDroppedCounter: meter.createCounter("openclaw.diagnostic.async_queue.dropped", {
-			unit: "1",
-			description: "Async diagnostic queue drops by dropped event class"
-		}),
-		payloadLargeCounter: meter.createCounter("openclaw.payload.large", {
-			unit: "1",
-			description: "Oversized payload diagnostics by surface and action"
-		}),
-		payloadLargeBytesHistogram: meter.createHistogram("openclaw.payload.large_bytes", {
-			unit: "By",
-			description: "Oversized payload byte sizes by surface and action"
-		}),
-		livenessWarningCounter: meter.createCounter("openclaw.liveness.warning", {
-			unit: "1",
-			description: "Diagnostic liveness warning events"
-		}),
-		livenessEventLoopDelayP99Histogram: meter.createHistogram("openclaw.liveness.event_loop_delay_p99_ms", {
-			unit: "ms",
-			description: "P99 event-loop delay reported by diagnostic liveness warnings"
-		}),
-		livenessEventLoopDelayMaxHistogram: meter.createHistogram("openclaw.liveness.event_loop_delay_max_ms", {
-			unit: "ms",
-			description: "Maximum event-loop delay reported by diagnostic liveness warnings"
-		}),
-		livenessEventLoopUtilizationHistogram: meter.createHistogram("openclaw.liveness.event_loop_utilization", {
-			unit: "1",
-			description: "Event-loop utilization reported by diagnostic liveness warnings"
-		}),
-		livenessCpuCoreRatioHistogram: meter.createHistogram("openclaw.liveness.cpu_core_ratio", {
-			unit: "1",
-			description: "CPU core ratio reported by diagnostic liveness warnings"
-		}),
-		telemetryExporterCounter: meter.createCounter("openclaw.telemetry.exporter.events", {
-			unit: "1",
-			description: "Diagnostic telemetry exporter lifecycle and failure events"
-		})
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-recorder-runtime.ts
-function createDiagnosticsRecorderRuntime(params) {
-	return {
-		...params.metrics,
-		...params.traces,
-		contentCapturePolicy: params.contentCapturePolicy,
-		tracesEnabled: params.tracesEnabled
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-recorders-harness.ts
-function createHarnessRecorders(runtime) {
-	const { harnessDurationHistogram, modelFailoverCounter, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, trackTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
-	const harnessRunMetricAttrs = (evt) => ({
-		"openclaw.harness.id": lowCardinalityAttr(evt.harnessId, "unknown"),
-		"openclaw.harness.plugin": lowCardinalityAttr(evt.pluginId),
-		...evt.type === "harness.run.started" ? {} : { "openclaw.outcome": evt.type === "harness.run.error" ? "error" : evt.outcome },
-		"openclaw.provider": lowCardinalityAttr(evt.provider, "unknown"),
-		"openclaw.model": lowCardinalityAttr(evt.model, "unknown"),
-		...evt.channel ? { "openclaw.channel": lowCardinalityAttr(evt.channel) } : {}
-	});
-	const recordHarnessRunStarted = (evt, metadata) => {
-		if (!tracesEnabled || !metadata.trusted) return;
-		trackTrustedSpan(evt, metadata, spanWithDuration("openclaw.harness.run", harnessRunMetricAttrs(evt), void 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			startTimeMs: evt.ts
-		}));
-	};
-	const recordHarnessRunCompleted = (evt, metadata, privateData) => {
-		harnessDurationHistogram.record(evt.durationMs, harnessRunMetricAttrs(evt));
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...harnessRunMetricAttrs(evt) };
-		if (evt.resultClassification) spanAttrs["openclaw.harness.result_classification"] = lowCardinalityAttr(evt.resultClassification);
-		if (typeof evt.yieldDetected === "boolean") spanAttrs["openclaw.harness.yield_detected"] = evt.yieldDetected;
-		if (evt.itemLifecycle) {
-			spanAttrs["openclaw.harness.items.started"] = evt.itemLifecycle.startedCount;
-			spanAttrs["openclaw.harness.items.completed"] = evt.itemLifecycle.completedCount;
-			spanAttrs["openclaw.harness.items.active"] = evt.itemLifecycle.activeCount;
-		}
-		const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
-		if (redactedError) spanAttrs["openclaw.error"] = redactedError;
-		const trustedTrace = trustedTraceContext(evt, metadata);
-		const trackedSpan = trustedTrace?.spanId ? activeTrustedSpans.get(trustedTrace.spanId) : void 0;
-		const span = trackedSpan ?? spanWithDuration("openclaw.harness.run", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		if (evt.outcome === "error") span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactedError ?? "error"
-		});
-		if (trackedSpan && trustedTrace?.spanId) {
-			completeTrackedLifecycleSpan(trustedTrace.spanId, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
-	};
-	const recordHarnessRunError = (evt, metadata, privateData) => {
-		const errorType = lowCardinalityAttr(evt.errorCategory, "other");
-		const attrs = {
-			...harnessRunMetricAttrs(evt),
-			"openclaw.harness.phase": evt.phase,
-			"openclaw.errorCategory": errorType
-		};
-		harnessDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
-		const spanAttrs = {
-			...attrs,
-			"error.type": errorType,
-			...redactedError ? { "openclaw.error": redactedError } : {},
-			...evt.cleanupFailed ? { "openclaw.harness.cleanup_failed": true } : {}
-		};
-		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.harness.run", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactedError ?? errorType
-		});
-		span.end(evt.ts);
-	};
-	const recordContextAssembled = (evt, metadata) => {
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			"openclaw.context.message_count": evt.messageCount,
-			"openclaw.context.history_text_chars": evt.historyTextChars,
-			"openclaw.context.history_image_blocks": evt.historyImageBlocks,
-			"openclaw.context.max_message_text_chars": evt.maxMessageTextChars,
-			"openclaw.context.system_prompt_chars": evt.systemPromptChars,
-			"openclaw.context.prompt_chars": evt.promptChars,
-			"openclaw.context.prompt_images": evt.promptImages
-		};
-		addRunAttrs(spanAttrs, evt);
-		if (evt.contextTokenBudget !== void 0) spanAttrs["openclaw.context.token_budget"] = evt.contextTokenBudget;
-		if (evt.reserveTokens !== void 0) spanAttrs["openclaw.context.reserve_tokens"] = evt.reserveTokens;
-		spanWithDuration("openclaw.context.assembled", spanAttrs, 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		}).end(evt.ts);
-	};
-	const recordModelFailover = (evt, metadata) => {
-		const metricAttrs = {
-			"openclaw.failover.reason": lowCardinalityAttr(evt.reason, "unknown"),
-			"openclaw.failover.suspended": evt.suspended === void 0 ? "unknown" : String(evt.suspended),
-			"openclaw.lane": lowCardinalityQueueLaneAttr(evt.lane, "unknown"),
-			"openclaw.model": lowCardinalityAttr(evt.fromModel),
-			"openclaw.provider": lowCardinalityAttr(evt.fromProvider),
-			"openclaw.failover.to_model": lowCardinalityAttr(evt.toModel),
-			"openclaw.failover.to_provider": lowCardinalityAttr(evt.toProvider)
-		};
-		modelFailoverCounter.add(1, metricAttrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { "openclaw.failover.reason": lowCardinalityAttr(evt.reason, "unknown") };
-		if (evt.fromProvider) spanAttrs["openclaw.provider"] = evt.fromProvider;
-		if (evt.fromModel) spanAttrs["openclaw.model"] = evt.fromModel;
-		if (evt.toProvider) spanAttrs["openclaw.failover.to_provider"] = evt.toProvider;
-		if (evt.toModel) spanAttrs["openclaw.failover.to_model"] = evt.toModel;
-		if (evt.lane) spanAttrs["openclaw.lane"] = lowCardinalityQueueLaneAttr(evt.lane, "unknown");
-		if (evt.suspended !== void 0) spanAttrs["openclaw.failover.suspended"] = evt.suspended;
-		if (evt.cascadeDepth !== void 0) spanAttrs["openclaw.failover.cascade_depth"] = evt.cascadeDepth;
-		spanWithDuration("openclaw.model.failover", spanAttrs, 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		}).end(evt.ts);
-	};
-	return {
-		recordHarnessRunStarted,
-		recordHarnessRunCompleted,
-		recordHarnessRunError,
-		recordContextAssembled,
-		recordModelFailover
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-genai-attributes.ts
-function hasOtelSemconvOptIn(value, optIn) {
-	return value?.split(",").map((part) => part.trim()).includes(optIn) ?? false;
-}
-function emitLatestGenAiSemconv() {
-	return hasOtelSemconvOptIn(process.env[OTEL_SEMCONV_STABILITY_OPT_IN_ENV], GEN_AI_LATEST_EXPERIMENTAL_OPT_IN);
-}
-function genAiOperationName(api, observationUnit) {
-	if (observationUnit === "turn") return GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT;
-	const normalized = api?.trim().toLowerCase();
-	if (!normalized) return "chat";
-	if (normalized === "completions" || normalized.endsWith("-completions")) return "text_completion";
-	if (normalized === "generate_content" || normalized.includes("generative-ai")) return "generate_content";
-	return "chat";
-}
-function positiveFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
-}
-function assignPositiveNumberAttr(attrs, key, value) {
-	const normalized = positiveFiniteNumber(value);
-	if (normalized !== void 0) attrs[key] = normalized;
-}
-function assignModelCallSizeTimingAttrs(attrs, evt) {
-	assignPositiveNumberAttr(attrs, "openclaw.model_call.request_bytes", evt.requestPayloadBytes);
-	assignPositiveNumberAttr(attrs, "openclaw.model_call.response_bytes", evt.responseStreamBytes);
-	assignPositiveNumberAttr(attrs, "openclaw.model_call.time_to_first_byte_ms", evt.timeToFirstByteMs);
-}
-function assignNumberAttr(attrs, key, value) {
-	if (typeof value === "number" && Number.isFinite(value)) attrs[key] = value;
-}
-function modelCallPromptTokens(usage) {
-	if (typeof usage.promptTokens === "number" && Number.isFinite(usage.promptTokens)) return usage.promptTokens;
-	const input = usage.input ?? 0;
-	const cacheRead = usage.cacheRead ?? 0;
-	const cacheWrite = usage.cacheWrite ?? 0;
-	const total = input + cacheRead + cacheWrite;
-	return total > 0 ? total : void 0;
-}
-function assignModelCallPromptStatsAttrs(attrs, evt) {
-	const stats = evt.promptStats;
-	if (!stats) return;
-	for (const [key, value] of [
-		["openclaw.model_call.prompt.input_messages_count", stats.inputMessagesCount],
-		["openclaw.model_call.prompt.input_messages_chars", stats.inputMessagesChars],
-		["openclaw.model_call.prompt.system_prompt_chars", stats.systemPromptChars],
-		["openclaw.model_call.prompt.tool_definitions_count", stats.toolDefinitionsCount],
-		["openclaw.model_call.prompt.tool_definitions_chars", stats.toolDefinitionsChars],
-		["openclaw.model_call.prompt.total_chars", stats.totalChars]
-	]) assignNumberAttr(attrs, key, value);
-}
-function assignModelCallUsageAttrs(attrs, evt) {
-	const usage = evt.usage;
-	if (!usage) return;
-	const promptTokens = modelCallPromptTokens(usage);
-	for (const [key, value] of [
-		["openclaw.model_call.usage.input_tokens", usage.input],
-		["openclaw.model_call.usage.output_tokens", usage.output],
-		["openclaw.model_call.usage.cache_read_input_tokens", usage.cacheRead],
-		["openclaw.model_call.usage.cache_creation_input_tokens", usage.cacheWrite],
-		["openclaw.model_call.usage.reasoning_output_tokens", usage.reasoningTokens],
-		["openclaw.model_call.usage.prompt_tokens", promptTokens],
-		["openclaw.model_call.usage.total_tokens", usage.total],
-		["gen_ai.usage.input_tokens", promptTokens],
-		["gen_ai.usage.output_tokens", usage.output],
-		["gen_ai.usage.cache_read.input_tokens", usage.cacheRead],
-		["gen_ai.usage.cache_creation.input_tokens", usage.cacheWrite]
-	]) assignPositiveNumberAttr(attrs, key, value);
-}
-function assignGenAiSpanIdentityAttrs(attrs, input) {
-	if (emitLatestGenAiSemconv()) attrs["gen_ai.provider.name"] = lowCardinalityAttr(input.provider);
-	else attrs["gen_ai.system"] = lowCardinalityAttr(input.provider);
-	if (input.model) attrs["gen_ai.request.model"] = redactSensitiveText(input.model.trim());
-	attrs["gen_ai.operation.name"] = genAiOperationName(input.api, input.observationUnit);
-}
-function assignGenAiModelCallAttrs(attrs, evt) {
-	assignGenAiSpanIdentityAttrs(attrs, evt);
-	attrs["openclaw.model_call.observation_unit"] = modelCallObservationUnit(evt);
-}
-function modelCallObservationUnit(evt) {
-	return evt.observationUnit ?? "request";
-}
-function modelCallSpanName(evt) {
-	if (!emitLatestGenAiSemconv()) return "openclaw.model.call";
-	const operationName = genAiOperationName(evt.api, evt.observationUnit);
-	return operationName === GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT ? operationName : `${operationName} ${lowCardinalityAttr(evt.model)}`;
-}
-function modelCallSpanKind() {
-	return SpanKind.CLIENT;
-}
-function addUpstreamRequestIdSpanEvent(span, upstreamRequestIdHash) {
-	if (!upstreamRequestIdHash) return;
-	const boundedHash = lowCardinalityAttr(upstreamRequestIdHash);
-	if (boundedHash === "unknown") return;
-	span.addEvent?.("openclaw.provider.request", { "openclaw.upstreamRequestIdHash": boundedHash });
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-genai-content.ts
-function textPart(content) {
-	return {
-		type: "text",
-		content
-	};
-}
-function textPartContent(part) {
-	if (part.type !== "text") return;
-	if (typeof part.text === "string") return part.text;
-	return typeof part.content === "string" ? part.content : void 0;
-}
-function toolCallResponseValue(value) {
-	if (!Array.isArray(value)) return value;
-	const textItems = [];
-	for (const item of value) {
-		const text = typeof item === "string" ? item : isRecord(item) ? textPartContent(item) : void 0;
-		if (typeof text !== "string") return value;
-		textItems.push(text);
-	}
-	const kept = textItems.slice(0, 200);
-	const joined = kept.filter((text) => text.length > 0).join("\n");
-	if (joined.length === 0) return value;
-	const omitted = textItems.length - kept.length;
-	return omitted > 0 ? `${joined}\n...(${omitted} more text parts omitted)` : joined;
-}
-function toolCallResponsePart(part) {
-	return {
-		type: "tool_call_response",
-		...typeof part.id === "string" ? { id: part.id } : {},
-		response: toolCallResponseValue(part.response ?? part.result ?? part.content ?? part.details ?? "")
-	};
-}
-function contentParts(value) {
-	if (typeof value === "string") return value.length > 0 ? [textPart(value)] : [];
-	if (!Array.isArray(value)) {
-		if (value === void 0 || value === null) return [];
-		if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return [textPart(String(value))];
-		const json = safeJsonString(value, MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
-		return json ? [textPart(json)] : [];
-	}
-	const parts = [];
-	for (const part of value) {
-		if (typeof part === "string") {
-			if (part.length > 0) parts.push(textPart(part));
-			continue;
-		}
-		if (!isRecord(part)) continue;
-		const text = textPartContent(part);
-		if (text !== void 0) parts.push(textPart(text));
-		else if (part.type === "thinking" && typeof part.thinking === "string") parts.push({
-			type: "reasoning",
-			content: part.thinking
-		});
-		else if (part.type === "toolCall" && typeof part.name === "string") parts.push({
-			type: "tool_call",
-			name: part.name,
-			...typeof part.id === "string" ? { id: part.id } : {},
-			...part.arguments !== void 0 ? { arguments: part.arguments } : {}
-		});
-		else if (part.type === "tool_call" && typeof part.name === "string") parts.push({
-			type: "tool_call",
-			name: part.name,
-			...typeof part.id === "string" ? { id: part.id } : {},
-			...part.arguments !== void 0 ? { arguments: part.arguments } : {}
-		});
-		else if (part.type === "tool_call_response") parts.push(toolCallResponsePart(part));
-		else if (part.type === "image") {
-			const data = typeof part.data === "string" ? part.data : void 0;
-			parts.push({
-				type: "blob",
-				modality: "image",
-				...typeof part.mimeType === "string" ? { mime_type: part.mimeType } : {},
-				...typeof part.mime_type === "string" ? { mime_type: part.mime_type } : {},
-				...data ? { content: data } : {}
-			});
-		}
-	}
-	return parts;
-}
-function normalizeGenAiMessage(value, fallbackRole = "user") {
-	if (typeof value === "string") return {
-		role: fallbackRole,
-		parts: [textPart(value)]
-	};
-	if (!isRecord(value)) return;
-	const rawRole = typeof value.role === "string" ? value.role : fallbackRole;
-	const role = rawRole === "toolResult" ? "tool" : rawRole;
-	let parts;
-	if (role === "tool") {
-		const explicitParts = contentParts(value.parts);
-		parts = explicitParts.length > 0 ? explicitParts : [toolCallResponsePart({
-			id: value.toolCallId,
-			response: value.content ?? value.details ?? ""
-		})];
-	} else parts = contentParts(value.parts ?? value.content);
-	if (parts.length === 0) return;
-	return {
-		role,
-		parts,
-		...typeof value.name === "string" ? { name: value.name } : {},
-		...typeof value.finish_reason === "string" ? { finish_reason: value.finish_reason } : {},
-		...typeof value.stopReason === "string" ? { finish_reason: value.stopReason } : {}
-	};
-}
-function normalizeGenAiMessages(value, fallbackRole) {
-	const source = Array.isArray(value) ? value : value === void 0 ? [] : [value];
-	const messages = [];
-	for (const item of source.slice(0, 200)) {
-		const message = normalizeGenAiMessage(item, fallbackRole);
-		if (message) messages.push(message);
-	}
-	return messages;
-}
-function normalizeGenAiToolDefinition(value) {
-	if (!isRecord(value) || typeof value.name !== "string" || value.name.trim().length === 0) return;
-	return {
-		type: typeof value.type === "string" ? value.type : "function",
-		name: value.name,
-		...typeof value.description === "string" ? { description: value.description } : {},
-		...value.parameters !== void 0 ? { parameters: value.parameters } : {}
-	};
-}
-function normalizeGenAiToolDefinitions(value) {
-	if (!Array.isArray(value)) return [];
-	const definitions = [];
-	for (const item of value.slice(0, 200)) {
-		const definition = normalizeGenAiToolDefinition(item);
-		if (definition) definitions.push(definition);
-	}
-	return definitions;
-}
-function assignJsonAttribute(attributes, key, value) {
-	const json = safeJsonString(value, MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
-	if (json) attributes[key] = json;
-}
-function assignGenAiModelContentAttributes(attributes, content, policy) {
-	if (policy.systemPrompt && typeof content?.systemPrompt === "string") assignJsonAttribute(attributes, ATTR_GEN_AI_SYSTEM_INSTRUCTIONS, [textPart(content.systemPrompt)]);
-	if (policy.inputMessages) {
-		const inputMessages = normalizeGenAiMessages(content?.inputMessages, "user");
-		if (inputMessages.length > 0) {
-			assignJsonAttribute(attributes, ATTR_GEN_AI_INPUT_MESSAGES, inputMessages);
-			assignJsonAttribute(attributes, "input.value", inputMessages);
-			attributes["input.mime_type"] = "application/json";
-		}
-	}
-	if (policy.toolDefinitions) {
-		const toolDefinitions = normalizeGenAiToolDefinitions(content?.toolDefinitions);
-		if (toolDefinitions.length > 0) assignJsonAttribute(attributes, ATTR_GEN_AI_TOOL_DEFINITIONS, toolDefinitions);
-	}
-	if (policy.outputMessages) {
-		const outputMessages = normalizeGenAiMessages(content?.outputMessages, "assistant");
-		if (outputMessages.length > 0) {
-			assignJsonAttribute(attributes, ATTR_GEN_AI_OUTPUT_MESSAGES, outputMessages);
-			assignJsonAttribute(attributes, "output.value", outputMessages);
-			attributes["output.mime_type"] = "application/json";
-		}
-	}
-}
-function assignOtelContentAttribute(attributes, key, value) {
-	const normalized = normalizeOtelContentValue(value);
-	if (normalized) attributes[key] = normalized;
-}
-function assignOtelToolIdentityAttributes(attributes, evt) {
-	attributes["gen_ai.operation.name"] = GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL;
-	const toolCallId = evt.toolCallId?.trim();
-	if (toolCallId) attributes[ATTR_GEN_AI_TOOL_CALL_ID] = toolCallId;
-}
-function assignOtelModelContentAttributes(attributes, content, policy) {
-	assignGenAiModelContentAttributes(attributes, content, policy);
-	if (policy.inputMessages) assignOtelContentAttribute(attributes, "openclaw.content.input_messages", content?.inputMessages);
-	if (policy.toolDefinitions) assignOtelContentAttribute(attributes, "openclaw.content.tool_definitions", content?.toolDefinitions);
-	if (policy.outputMessages) assignOtelContentAttribute(attributes, "openclaw.content.output_messages", content?.outputMessages);
-	if (policy.systemPrompt) assignOtelContentAttribute(attributes, "openclaw.content.system_prompt", content?.systemPrompt);
-}
-function assignOtelToolContentAttributes(attributes, content, policy) {
-	if (policy.toolInputs) {
-		const toolInput = normalizeOtelContentValue(content?.toolInput);
-		if (toolInput) {
-			attributes[ATTR_GEN_AI_TOOL_CALL_ARGUMENTS] = toolInput;
-			attributes["openclaw.content.tool_input"] = toolInput;
-		}
-	}
-	if (policy.toolOutputs) {
-		const toolOutput = normalizeOtelContentValue(content?.toolOutput);
-		if (toolOutput) {
-			attributes[ATTR_GEN_AI_TOOL_CALL_RESULT] = toolOutput;
-			attributes["openclaw.content.tool_output"] = toolOutput;
-		}
-	}
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-recorders-model.ts
-function createModelRecorders(runtime) {
-	const { genAiOperationDurationHistogram, modelCallDurationHistogram, modelCallRequestBytesHistogram, modelCallResponseBytesHistogram, modelCallTimeToFirstByteHistogram, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, contentCapturePolicy, tracesEnabled } = runtime;
-	const modelCallMetricAttrs = (evt) => ({
-		"openclaw.provider": evt.provider,
-		"openclaw.model": evt.model,
-		"openclaw.api": lowCardinalityAttr(evt.api),
-		"openclaw.transport": lowCardinalityAttr(evt.transport),
-		"openclaw.model_call.observation_unit": modelCallObservationUnit(evt)
-	});
-	const genAiModelCallMetricAttrs = (evt, errorType) => ({
-		"gen_ai.operation.name": genAiOperationName(evt.api, evt.observationUnit),
-		"gen_ai.provider.name": lowCardinalityAttr(evt.provider),
-		"gen_ai.request.model": lowCardinalityAttr(evt.model),
-		...errorType ? { "error.type": errorType } : {}
-	});
-	const recordGenAiModelCallDuration = (evt, errorType) => {
-		genAiOperationDurationHistogram.record(evt.durationMs / 1e3, genAiModelCallMetricAttrs(evt, errorType));
-	};
-	const recordModelCallSizeTimingMetrics = (evt, attrs) => {
-		const requestPayloadBytes = positiveFiniteNumber(evt.requestPayloadBytes);
-		if (requestPayloadBytes !== void 0) modelCallRequestBytesHistogram.record(requestPayloadBytes, attrs);
-		const responseStreamBytes = positiveFiniteNumber(evt.responseStreamBytes);
-		if (responseStreamBytes !== void 0) modelCallResponseBytesHistogram.record(responseStreamBytes, attrs);
-		const timeToFirstByteMs = positiveFiniteNumber(evt.timeToFirstByteMs);
-		if (timeToFirstByteMs !== void 0) modelCallTimeToFirstByteHistogram.record(timeToFirstByteMs, attrs);
-	};
-	const recordModelCallStarted = (evt, metadata) => {
-		if (!tracesEnabled || !metadata.trusted) return;
-		const spanAttrs = {
-			"openclaw.provider": evt.provider,
-			"openclaw.model": evt.model
-		};
-		assignGenAiModelCallAttrs(spanAttrs, evt);
-		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
-		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
-		assignModelCallPromptStatsAttrs(spanAttrs, evt);
-		trackTrustedSpan(evt, metadata, spanWithDuration(modelCallSpanName(evt), spanAttrs, void 0, {
-			kind: modelCallSpanKind(),
-			parentContext: activeTrustedParentContext(evt, metadata),
-			startTimeMs: evt.ts
-		}));
-	};
-	const recordModelCallCompleted = (evt, metadata, modelContent) => {
-		const metricAttrs = modelCallMetricAttrs(evt);
-		modelCallDurationHistogram.record(evt.durationMs, metricAttrs);
-		recordModelCallSizeTimingMetrics(evt, metricAttrs);
-		recordGenAiModelCallDuration(evt);
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			"openclaw.provider": evt.provider,
-			"openclaw.model": evt.model
-		};
-		assignGenAiModelCallAttrs(spanAttrs, evt);
-		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
-		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
-		assignModelCallSizeTimingAttrs(spanAttrs, evt);
-		assignModelCallPromptStatsAttrs(spanAttrs, evt);
-		assignModelCallUsageAttrs(spanAttrs, evt);
-		assignOtelModelContentAttributes(spanAttrs, modelContent, contentCapturePolicy);
-		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration(modelCallSpanName(evt), spanAttrs, evt.durationMs, {
-			kind: modelCallSpanKind(),
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		addUpstreamRequestIdSpanEvent(span, evt.upstreamRequestIdHash);
-		span.end(evt.ts);
-	};
-	const recordModelCallError = (evt, metadata, modelContent) => {
-		const errorType = lowCardinalityAttr(evt.errorCategory, "other");
-		const metricAttrs = {
-			...modelCallMetricAttrs(evt),
-			"openclaw.errorCategory": errorType,
-			...evt.failureKind ? { "openclaw.failureKind": lowCardinalityAttr(evt.failureKind, "other") } : {}
-		};
-		modelCallDurationHistogram.record(evt.durationMs, metricAttrs);
-		recordModelCallSizeTimingMetrics(evt, metricAttrs);
-		recordGenAiModelCallDuration(evt, errorType);
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			"openclaw.provider": evt.provider,
-			"openclaw.model": evt.model,
-			"openclaw.errorCategory": errorType,
-			"error.type": errorType
-		};
-		if (evt.failureKind) spanAttrs["openclaw.failureKind"] = lowCardinalityAttr(evt.failureKind, "other");
-		assignGenAiModelCallAttrs(spanAttrs, evt);
-		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
-		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
-		assignModelCallSizeTimingAttrs(spanAttrs, evt);
-		assignModelCallPromptStatsAttrs(spanAttrs, evt);
-		assignModelCallUsageAttrs(spanAttrs, evt);
-		assignOtelModelContentAttributes(spanAttrs, modelContent, contentCapturePolicy);
-		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration(modelCallSpanName(evt), spanAttrs, evt.durationMs, {
-			kind: modelCallSpanKind(),
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		addUpstreamRequestIdSpanEvent(span, evt.upstreamRequestIdHash);
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactSensitiveText(evt.errorCategory)
-		});
-		span.end(evt.ts);
-	};
-	return {
-		recordModelCallSizeTimingMetrics,
-		recordModelCallStarted,
-		recordModelCallCompleted,
-		recordModelCallError
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-recorders-operations.ts
-function createOperationsRecorders(runtime) {
-	const { durationHistogram, queueDepthHistogram, queueWaitHistogram, laneEnqueueCounter, laneDequeueCounter, sessionStateCounter, sessionTurnCreatedCounter, sessionStuckCounter, sessionStuckAgeHistogram, sessionRecoveryRequestedCounter, sessionRecoveryCompletedCounter, sessionRecoveryAgeHistogram, talkEventCounter, talkEventDurationHistogram, talkAudioBytesHistogram, runAttemptCounter, toolLoopCounter, memoryRssHistogram, memoryHeapUsedHistogram, memoryHeapTotalHistogram, memoryExternalHistogram, memoryArrayBuffersHistogram, memoryPressureCounter, asyncQueueDroppedCounter, tracer, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
-	const recordLaneEnqueue = (evt) => {
-		const attrs = { "openclaw.lane": lowCardinalityQueueLaneAttr(evt.lane) };
-		laneEnqueueCounter.add(1, attrs);
-		queueDepthHistogram.record(evt.queueSize, attrs);
-	};
-	const recordLaneDequeue = (evt) => {
-		const attrs = { "openclaw.lane": lowCardinalityQueueLaneAttr(evt.lane) };
-		laneDequeueCounter.add(1, attrs);
-		queueDepthHistogram.record(evt.queueSize, attrs);
-		if (typeof evt.waitMs === "number") queueWaitHistogram.record(evt.waitMs, attrs);
-	};
-	const recordSessionState = (evt) => {
-		const attrs = { "openclaw.state": evt.state };
-		if (evt.reason) attrs["openclaw.reason"] = redactSensitiveText(evt.reason);
-		sessionStateCounter.add(1, attrs);
-	};
-	const recordSessionTurnCreated = (evt) => {
-		sessionTurnCreatedCounter.add(1, {
-			"openclaw.agent": lowCardinalityAttr(evt.agentId, "unknown"),
-			"openclaw.channel": lowCardinalityAttr(evt.channel, "unknown"),
-			"openclaw.trigger": evt.trigger
-		});
-	};
-	const recordSessionStuck = (evt) => {
-		const attrs = { "openclaw.state": evt.state };
-		sessionStuckCounter.add(1, attrs);
-		if (typeof evt.ageMs === "number") sessionStuckAgeHistogram.record(evt.ageMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...attrs };
-		spanAttrs["openclaw.queueDepth"] = evt.queueDepth ?? 0;
-		spanAttrs["openclaw.ageMs"] = evt.ageMs;
-		const span = tracer.startSpan("openclaw.session.stuck", { attributes: spanAttrs });
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: "session stuck"
-		});
-		span.end();
-	};
-	const sessionRecoveryAttrs = (evt) => {
-		const attrs = { "openclaw.state": evt.state };
-		if (evt.reason) attrs["openclaw.reason"] = redactSensitiveText(evt.reason);
-		if (evt.activeWorkKind) attrs["openclaw.active_work_kind"] = evt.activeWorkKind;
-		return attrs;
-	};
-	const recordSessionRecoveryRequested = (evt) => {
-		const attrs = sessionRecoveryAttrs(evt);
-		attrs["openclaw.action"] = evt.allowActiveAbort ? "abort" : "recover";
-		sessionRecoveryRequestedCounter.add(1, attrs);
-		sessionRecoveryAgeHistogram.record(evt.ageMs, attrs);
-	};
-	const recordSessionRecoveryCompleted = (evt) => {
-		const attrs = sessionRecoveryAttrs(evt);
-		attrs["openclaw.status"] = evt.status;
-		attrs["openclaw.action"] = lowCardinalityAttr(evt.action, "unknown");
-		if (evt.outcomeReason) attrs["openclaw.reason"] = redactSensitiveText(evt.outcomeReason);
-		sessionRecoveryCompletedCounter.add(1, attrs);
-		sessionRecoveryAgeHistogram.record(evt.ageMs, attrs);
-	};
-	const talkEventAttrs = (evt) => ({
-		"openclaw.talk.brain": lowCardinalityAttr(evt.brain),
-		"openclaw.talk.event_type": lowCardinalityAttr(evt.talkEventType),
-		"openclaw.talk.mode": lowCardinalityAttr(evt.mode),
-		"openclaw.talk.provider": lowCardinalityAttr(evt.provider),
-		"openclaw.talk.transport": lowCardinalityAttr(evt.transport)
-	});
-	const recordTalkEvent = (evt, metadata) => {
-		if (!metadata.trusted) return;
-		const attrs = talkEventAttrs(evt);
-		talkEventCounter.add(1, attrs);
-		if (typeof evt.durationMs === "number") talkEventDurationHistogram.record(evt.durationMs, attrs);
-		if (typeof evt.byteLength === "number") talkAudioBytesHistogram.record(evt.byteLength, attrs);
-	};
-	const recordRunAttempt = (evt) => {
-		runAttemptCounter.add(1, { "openclaw.attempt": evt.attempt });
-	};
-	const toolLoopAttrs = (evt) => ({
-		"openclaw.toolName": lowCardinalityAttr(evt.toolName, "tool"),
-		"openclaw.loop.level": evt.level,
-		"openclaw.loop.action": evt.action,
-		"openclaw.loop.detector": evt.detector,
-		"openclaw.loop.count": evt.count,
-		...evt.pairedToolName ? { "openclaw.loop.paired_tool": lowCardinalityAttr(evt.pairedToolName, "tool") } : {}
-	});
-	const recordToolLoop = (evt) => {
-		const attrs = toolLoopAttrs(evt);
-		toolLoopCounter.add(1, attrs);
-		if (!tracesEnabled) return;
-		const span = spanWithDuration("openclaw.tool.loop", attrs, 0, { endTimeMs: evt.ts });
-		if (evt.level === "critical" || evt.action === "block") span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: `${evt.detector}:${evt.action}`
-		});
-		span.end(evt.ts);
-	};
-	const recordMemoryUsageMetrics = (evt, attrs = {}) => {
-		memoryRssHistogram.record(evt.memory.rssBytes, attrs);
-		memoryHeapUsedHistogram.record(evt.memory.heapUsedBytes, attrs);
-		memoryHeapTotalHistogram.record(evt.memory.heapTotalBytes, attrs);
-		memoryExternalHistogram.record(evt.memory.externalBytes, attrs);
-		memoryArrayBuffersHistogram.record(evt.memory.arrayBuffersBytes, attrs);
-	};
-	const recordMemorySample = (evt) => {
-		recordMemoryUsageMetrics(evt);
-	};
-	const recordMemoryPressure = (evt) => {
-		const attrs = {
-			"openclaw.memory.level": evt.level,
-			"openclaw.memory.reason": evt.reason
-		};
-		memoryPressureCounter.add(1, attrs);
-		recordMemoryUsageMetrics(evt, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			...attrs,
-			"openclaw.memory.rss_bytes": evt.memory.rssBytes,
-			"openclaw.memory.heap_used_bytes": evt.memory.heapUsedBytes,
-			"openclaw.memory.heap_total_bytes": evt.memory.heapTotalBytes,
-			"openclaw.memory.external_bytes": evt.memory.externalBytes,
-			"openclaw.memory.array_buffers_bytes": evt.memory.arrayBuffersBytes,
-			...evt.thresholdBytes !== void 0 ? { "openclaw.memory.threshold_bytes": evt.thresholdBytes } : {},
-			...evt.rssGrowthBytes !== void 0 ? { "openclaw.memory.rss_growth_bytes": evt.rssGrowthBytes } : {},
-			...evt.windowMs !== void 0 ? { "openclaw.memory.window_ms": evt.windowMs } : {}
-		};
-		const span = spanWithDuration("openclaw.memory.pressure", spanAttrs, 0, { endTimeMs: evt.ts });
-		if (evt.level === "critical") span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: evt.reason
-		});
-		span.end(evt.ts);
-	};
-	const recordAsyncQueueDropped = (evt) => {
-		asyncQueueDroppedCounter.add(evt.droppedEvents, { "openclaw.diagnostic.async_queue.drop_class": "total" });
-		if (evt.droppedTrustedEvents !== void 0) asyncQueueDroppedCounter.add(evt.droppedTrustedEvents, { "openclaw.diagnostic.async_queue.drop_class": "trusted" });
-		if (evt.droppedUntrustedEvents !== void 0) asyncQueueDroppedCounter.add(evt.droppedUntrustedEvents, { "openclaw.diagnostic.async_queue.drop_class": "untrusted" });
-		if (evt.droppedPriorityEvents !== void 0) asyncQueueDroppedCounter.add(evt.droppedPriorityEvents, { "openclaw.diagnostic.async_queue.drop_class": "priority" });
-	};
-	const recordRunCompleted = (evt, metadata, privateData) => {
-		const attrs = {
-			"openclaw.outcome": evt.outcome,
-			"openclaw.provider": evt.provider ?? "unknown",
-			"openclaw.model": evt.model ?? "unknown"
-		};
-		if (evt.channel) attrs["openclaw.channel"] = evt.channel;
-		if (evt.blockedBy) attrs["openclaw.blocked_by"] = lowCardinalityAttr(evt.blockedBy, "unknown");
-		durationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { "openclaw.outcome": evt.outcome };
-		addRunAttrs(spanAttrs, evt);
-		if (evt.blockedBy) spanAttrs["openclaw.blocked_by"] = lowCardinalityAttr(evt.blockedBy, "unknown");
-		if (evt.errorCategory) spanAttrs["openclaw.errorCategory"] = lowCardinalityAttr(evt.errorCategory, "other");
-		const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
-		if (redactedError) spanAttrs["openclaw.error"] = redactedError;
-		const trustedTrace = trustedTraceContext(evt, metadata);
-		const trackedSpan = trustedTrace?.spanId ? activeTrustedSpans.get(trustedTrace.spanId) : void 0;
-		const span = trackedSpan ?? spanWithDuration("openclaw.run", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		if (evt.outcome === "error") {
-			const message = redactedError ?? (evt.errorCategory ? redactSensitiveText(evt.errorCategory) : void 0);
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				...message ? { message } : {}
-			});
-		}
-		if (trackedSpan && trustedTrace?.spanId) {
-			completeTrackedLifecycleSpan(trustedTrace.spanId, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
-	};
-	return {
-		recordLaneEnqueue,
-		recordLaneDequeue,
-		recordSessionState,
-		recordSessionTurnCreated,
-		recordSessionStuck,
-		recordSessionRecoveryRequested,
-		recordSessionRecoveryCompleted,
-		recordTalkEvent,
-		recordRunAttempt,
-		recordToolLoop,
-		recordMemoryUsageMetrics,
-		recordMemorySample,
-		recordMemoryPressure,
-		recordAsyncQueueDropped,
-		recordRunCompleted
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-recorders-tools.ts
-function createToolAndSystemRecorders(runtime) {
-	const { queueDepthHistogram, skillUsedCounter, toolExecutionDurationHistogram, toolExecutionBlockedCounter, execProcessDurationHistogram, payloadLargeCounter, payloadLargeBytesHistogram, livenessWarningCounter, livenessEventLoopDelayP99Histogram, livenessEventLoopDelayMaxHistogram, livenessEventLoopUtilizationHistogram, livenessCpuCoreRatioHistogram, telemetryExporterCounter, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, paramsSummaryAttrs, contentCapturePolicy, tracesEnabled } = runtime;
-	const toolExecutionBaseAttrs = (evt) => ({
-		"openclaw.toolName": evt.toolName,
-		"openclaw.tool.source": lowCardinalityAttr(evt.toolSource, "core"),
-		"gen_ai.tool.name": evt.toolName,
-		...evt.toolOwner ? { "openclaw.tool.owner": lowCardinalityAttr(evt.toolOwner) } : {},
-		...paramsSummaryAttrs(evt.paramsSummary)
-	});
-	const skillUsedAttrs = (evt) => ({
-		"openclaw.skill.name": lowCardinalityAttr(evt.skillName, "skill"),
-		"openclaw.skill.source": lowCardinalityAttr(evt.skillSource),
-		"openclaw.skill.activation": lowCardinalityAttr(evt.activation),
-		...evt.agentId ? { "openclaw.agent": lowCardinalityAttr(evt.agentId) } : {},
-		...evt.toolName ? { "openclaw.toolName": lowCardinalityAttr(evt.toolName, "tool") } : {}
-	});
-	const recordSkillUsed = (evt, metadata) => {
-		if (!metadata.trusted) return;
-		const attrs = skillUsedAttrs(evt);
-		skillUsedCounter.add(1, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...attrs };
-		addRunAttrs(spanAttrs, evt);
-		const span = spanWithDuration("openclaw.skill.used", spanAttrs, 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		span.end(evt.ts);
-	};
-	const recordToolExecutionStarted = (evt, metadata) => {
-		if (!tracesEnabled || !metadata.trusted) return;
-		const spanAttrs = toolExecutionBaseAttrs(evt);
-		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		trackTrustedSpan(evt, metadata, spanWithDuration("openclaw.tool.execution", spanAttrs, void 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			startTimeMs: evt.ts
-		}));
-	};
-	const recordToolExecutionCompleted = (evt, metadata, toolContent) => {
-		const attrs = toolExecutionBaseAttrs(evt);
-		toolExecutionDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...attrs };
-		addRunAttrs(spanAttrs, evt);
-		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		assignOtelToolContentAttributes(spanAttrs, toolContent, contentCapturePolicy);
-		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		span.end(evt.ts);
-	};
-	const recordToolExecutionError = (evt, metadata, toolContent) => {
-		const attrs = {
-			...toolExecutionBaseAttrs(evt),
-			"openclaw.errorCategory": lowCardinalityAttr(evt.errorCategory, "other")
-		};
-		toolExecutionDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...attrs };
-		addRunAttrs(spanAttrs, evt);
-		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		if (evt.errorCode) spanAttrs["openclaw.errorCode"] = lowCardinalityAttr(evt.errorCode, "other");
-		assignOtelToolContentAttributes(spanAttrs, toolContent, contentCapturePolicy);
-		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactSensitiveText(evt.errorCategory)
-		});
-		span.end(evt.ts);
-	};
-	const recordToolExecutionBlocked = (evt, metadata) => {
-		toolExecutionBlockedCounter.add(1, {
-			...toolExecutionBaseAttrs(evt),
-			"openclaw.deniedReason": lowCardinalityAttr(evt.deniedReason, "other")
-		});
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			...toolExecutionBaseAttrs(evt),
-			"openclaw.outcome": "blocked",
-			"openclaw.deniedReason": lowCardinalityAttr(evt.deniedReason, "other")
-		};
-		addRunAttrs(spanAttrs, evt);
-		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		const span = spanWithDuration("openclaw.tool.execution", spanAttrs, 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		span.end(evt.ts);
-	};
-	const recordPayloadLarge = (evt) => {
-		const attrs = {
-			"openclaw.payload.action": evt.action,
-			"openclaw.payload.surface": lowCardinalityAttr(evt.surface, "unknown"),
-			"openclaw.channel": lowCardinalityAttr(evt.channel, "none"),
-			"openclaw.plugin": lowCardinalityAttr(evt.pluginId, "none"),
-			"openclaw.reason": lowCardinalityAttr(evt.reason, "none")
-		};
-		payloadLargeCounter.add(1, attrs);
-		const bytes = positiveFiniteNumber(evt.bytes);
-		if (bytes !== void 0) payloadLargeBytesHistogram.record(bytes, attrs);
-	};
-	const recordExecProcessCompleted = (evt) => {
-		const attrs = {
-			"openclaw.exec.target": evt.target,
-			"openclaw.exec.mode": evt.mode,
-			"openclaw.outcome": evt.outcome
-		};
-		if (evt.failureKind) attrs["openclaw.failureKind"] = evt.failureKind;
-		execProcessDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			...attrs,
-			"openclaw.exec.command_length": evt.commandLength
-		};
-		if (typeof evt.exitCode === "number") spanAttrs["openclaw.exec.exit_code"] = evt.exitCode;
-		if (evt.exitSignal) spanAttrs["openclaw.exec.exit_signal"] = lowCardinalityAttr(evt.exitSignal, "other");
-		if (evt.timedOut !== void 0) spanAttrs["openclaw.exec.timed_out"] = evt.timedOut;
-		const span = spanWithDuration("openclaw.exec", spanAttrs, evt.durationMs, { endTimeMs: evt.ts });
-		if (evt.outcome === "failed") span.setStatus({
-			code: SpanStatusCode.ERROR,
-			...evt.failureKind ? { message: evt.failureKind } : {}
-		});
-		span.end(evt.ts);
-	};
-	const recordHeartbeat = (evt) => {
-		queueDepthHistogram.record(evt.queued, { "openclaw.channel": "heartbeat" });
-	};
-	const recordLivenessWarning = (evt) => {
-		const reason = evt.reasons.join(":");
-		const attrs = { "openclaw.liveness.reason": lowCardinalityAttr(reason, "unknown") };
-		livenessWarningCounter.add(1, attrs);
-		queueDepthHistogram.record(evt.queued, { "openclaw.channel": "liveness" });
-		if (evt.eventLoopDelayP99Ms !== void 0) livenessEventLoopDelayP99Histogram.record(evt.eventLoopDelayP99Ms, attrs);
-		if (evt.eventLoopDelayMaxMs !== void 0) livenessEventLoopDelayMaxHistogram.record(evt.eventLoopDelayMaxMs, attrs);
-		if (evt.eventLoopUtilization !== void 0) livenessEventLoopUtilizationHistogram.record(evt.eventLoopUtilization, attrs);
-		if (evt.cpuCoreRatio !== void 0) livenessCpuCoreRatioHistogram.record(evt.cpuCoreRatio, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			...attrs,
-			"openclaw.liveness.active": evt.active,
-			"openclaw.liveness.waiting": evt.waiting,
-			"openclaw.liveness.queued": evt.queued,
-			"openclaw.liveness.interval_ms": evt.intervalMs,
-			...evt.eventLoopDelayP99Ms !== void 0 ? { "openclaw.liveness.event_loop_delay_p99_ms": evt.eventLoopDelayP99Ms } : {},
-			...evt.eventLoopDelayMaxMs !== void 0 ? { "openclaw.liveness.event_loop_delay_max_ms": evt.eventLoopDelayMaxMs } : {},
-			...evt.eventLoopUtilization !== void 0 ? { "openclaw.liveness.event_loop_utilization": evt.eventLoopUtilization } : {},
-			...evt.cpuUserMs !== void 0 ? { "openclaw.liveness.cpu_user_ms": evt.cpuUserMs } : {},
-			...evt.cpuSystemMs !== void 0 ? { "openclaw.liveness.cpu_system_ms": evt.cpuSystemMs } : {},
-			...evt.cpuTotalMs !== void 0 ? { "openclaw.liveness.cpu_total_ms": evt.cpuTotalMs } : {},
-			...evt.cpuCoreRatio !== void 0 ? { "openclaw.liveness.cpu_core_ratio": evt.cpuCoreRatio } : {}
-		};
-		const span = spanWithDuration("openclaw.liveness.warning", spanAttrs, 0, { endTimeMs: evt.ts });
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: reason
-		});
-		span.end(evt.ts);
-	};
-	const recordDiagnosticPhaseCompleted = (evt) => {
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			"openclaw.phase": lowCardinalityAttr(evt.name, "unknown"),
-			...evt.cpuUserMs !== void 0 ? { "openclaw.phase.cpu_user_ms": evt.cpuUserMs } : {},
-			...evt.cpuSystemMs !== void 0 ? { "openclaw.phase.cpu_system_ms": evt.cpuSystemMs } : {},
-			...evt.cpuTotalMs !== void 0 ? { "openclaw.phase.cpu_total_ms": evt.cpuTotalMs } : {},
-			...evt.cpuCoreRatio !== void 0 ? { "openclaw.phase.cpu_core_ratio": evt.cpuCoreRatio } : {}
-		};
-		for (const [key, value] of Object.entries(evt.details ?? {})) spanAttrs[`openclaw.phase.detail.${key}`] = typeof value === "boolean" ? String(value) : value;
-		spanWithDuration("openclaw.diagnostic.phase", spanAttrs, evt.durationMs, { endTimeMs: evt.ts }).end(evt.ts);
-	};
-	const recordTelemetryExporter = (evt, metadata) => {
-		if (!metadata.trusted) return;
-		telemetryExporterCounter.add(1, {
-			"openclaw.exporter": lowCardinalityAttr(evt.exporter, "unknown"),
-			"openclaw.signal": evt.signal,
-			"openclaw.status": evt.status,
-			...evt.reason ? { "openclaw.reason": evt.reason } : {},
-			...evt.errorCategory ? { "openclaw.errorCategory": lowCardinalityAttr(evt.errorCategory, "other") } : {}
-		});
-	};
-	return {
-		recordSkillUsed,
-		recordToolExecutionStarted,
-		recordToolExecutionCompleted,
-		recordToolExecutionError,
-		recordToolExecutionBlocked,
-		recordPayloadLarge,
-		recordExecProcessCompleted,
-		recordHeartbeat,
-		recordLivenessWarning,
-		recordDiagnosticPhaseCompleted,
-		recordTelemetryExporter
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-recorders-usage.ts
-function createUsageRecorders(runtime) {
-	const { tokensCounter, genAiTokenUsageHistogram, costCounter, durationHistogram, contextHistogram, webhookReceivedCounter, webhookErrorCounter, webhookDurationHistogram, messageQueuedCounter, messageReceivedCounter, messageDispatchStartedCounter, messageDispatchCompletedCounter, messageDispatchDurationHistogram, messageProcessedCounter, messageDurationHistogram, messageDeliveryStartedCounter, messageDeliveryDurationHistogram, queueDepthHistogram, tracer, activeTrustedSpans, activeTrustedSpanAliases, trustedSpanAliasKey, spanWithDuration, trustedTraceContext, internalOrTrustedTraceContext, internalOrTrustedExplicitParentContext, activeTrustedParentContext, activeInternalOrTrustedContext, trackTrustedSpan, trackInternalOrTrustedSpan, getTrackedInternalOrTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
-	const recordModelUsage = (evt, metadata) => {
-		const attrs = {
-			"openclaw.channel": evt.channel ?? "unknown",
-			"openclaw.agent": lowCardinalityAttr(evt.agentId),
-			"openclaw.provider": evt.provider ?? "unknown",
-			"openclaw.model": evt.model ?? "unknown"
-		};
-		const genAiAttrs = {
-			"gen_ai.operation.name": "chat",
-			"gen_ai.provider.name": lowCardinalityAttr(evt.provider),
-			"gen_ai.request.model": lowCardinalityAttr(evt.model)
-		};
-		const usage = evt.usage;
-		if (usage.input) {
-			tokensCounter.add(usage.input, {
-				...attrs,
-				"openclaw.token": "input"
-			});
-			genAiTokenUsageHistogram.record(usage.input, {
-				...genAiAttrs,
-				"gen_ai.token.type": "input"
-			});
-		}
-		if (usage.output) {
-			tokensCounter.add(usage.output, {
-				...attrs,
-				"openclaw.token": "output"
-			});
-			genAiTokenUsageHistogram.record(usage.output, {
-				...genAiAttrs,
-				"gen_ai.token.type": "output"
-			});
-		}
-		if (usage.cacheRead) tokensCounter.add(usage.cacheRead, {
-			...attrs,
-			"openclaw.token": "cache_read"
-		});
-		if (usage.cacheWrite) tokensCounter.add(usage.cacheWrite, {
-			...attrs,
-			"openclaw.token": "cache_write"
-		});
-		if (usage.promptTokens) tokensCounter.add(usage.promptTokens, {
-			...attrs,
-			"openclaw.token": "prompt"
-		});
-		if (usage.total) tokensCounter.add(usage.total, {
-			...attrs,
-			"openclaw.token": "total"
-		});
-		if (evt.costUsd) costCounter.add(evt.costUsd, attrs);
-		if (evt.durationMs) durationHistogram.record(evt.durationMs, attrs);
-		if (evt.context?.limit) contextHistogram.record(evt.context.limit, {
-			...attrs,
-			"openclaw.context": "limit"
-		});
-		if (evt.context?.used) contextHistogram.record(evt.context.used, {
-			...attrs,
-			"openclaw.context": "used"
-		});
-		if (!tracesEnabled) return;
-		const genAiInputTokens = usage.promptTokens ?? (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-		const spanAttrs = {
-			...attrs,
-			"openclaw.tokens.input": usage.input ?? 0,
-			"openclaw.tokens.output": usage.output ?? 0,
-			"openclaw.tokens.cache_read": usage.cacheRead ?? 0,
-			"openclaw.tokens.cache_write": usage.cacheWrite ?? 0,
-			"openclaw.tokens.total": usage.total ?? 0
-		};
-		assignGenAiSpanIdentityAttrs(spanAttrs, evt);
-		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.input_tokens", genAiInputTokens);
-		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.output_tokens", usage.output);
-		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.cache_read.input_tokens", usage.cacheRead);
-		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.cache_creation.input_tokens", usage.cacheWrite);
-		spanWithDuration("openclaw.model.usage", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		}).end(evt.ts);
-	};
-	const recordWebhookReceived = (evt) => {
-		const attrs = {
-			"openclaw.channel": evt.channel ?? "unknown",
-			"openclaw.webhook": evt.updateType ?? "unknown"
-		};
-		webhookReceivedCounter.add(1, attrs);
-	};
-	const recordWebhookProcessed = (evt) => {
-		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.webhook": lowCardinalityAttr(evt.updateType)
-		};
-		if (typeof evt.durationMs === "number") webhookDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...attrs };
-		spanWithDuration("openclaw.webhook.processed", spanAttrs, evt.durationMs).end();
-	};
-	const recordWebhookError = (evt) => {
-		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.webhook": lowCardinalityAttr(evt.updateType)
-		};
-		webhookErrorCounter.add(1, attrs);
-		if (!tracesEnabled) return;
-		const redactedError = redactSensitiveText(evt.error);
-		const spanAttrs = {
-			...attrs,
-			"openclaw.error": redactedError
-		};
-		const span = tracer.startSpan("openclaw.webhook.error", { attributes: spanAttrs });
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactedError
-		});
-		span.end();
-	};
-	const recordMessageQueued = (evt) => {
-		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.source": lowCardinalityAttr(evt.source)
-		};
-		messageQueuedCounter.add(1, attrs);
-		if (typeof evt.queueDepth === "number") queueDepthHistogram.record(evt.queueDepth, attrs);
-	};
-	const recordMessageReceived = (evt) => {
-		messageReceivedCounter.add(1, {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.source": lowCardinalityAttr(evt.source)
-		});
-	};
-	const recordMessageDispatchStarted = (evt, metadata) => {
-		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.source": lowCardinalityAttr(evt.source)
-		};
-		messageDispatchStartedCounter.add(1, attrs);
-		if (!tracesEnabled) return;
-		const traceContext = internalOrTrustedTraceContext(evt, metadata);
-		if (!traceContext?.spanId || activeTrustedSpans.has(traceContext.spanId)) return;
-		trackInternalOrTrustedSpan(evt, metadata, spanWithDuration("openclaw.message.processed", attrs, void 0, {
-			parentContext: internalOrTrustedExplicitParentContext(evt, metadata),
-			startTimeMs: evt.ts
-		}));
-	};
-	const recordMessageDispatchCompleted = (evt) => {
-		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.outcome": evt.outcome,
-			"openclaw.reason": lowCardinalityAttr(evt.reason, "none"),
-			"openclaw.source": lowCardinalityAttr(evt.source)
-		};
-		messageDispatchCompletedCounter.add(1, attrs);
-		messageDispatchDurationHistogram.record(evt.durationMs, attrs);
-	};
-	const recordMessageProcessed = (evt, metadata) => {
-		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.outcome": evt.outcome ?? "unknown"
-		};
-		messageProcessedCounter.add(1, attrs);
-		if (typeof evt.durationMs === "number") messageDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...attrs };
-		if (evt.reason) spanAttrs["openclaw.reason"] = lowCardinalityAttr(evt.reason, "unknown");
-		const trackedSpan = getTrackedInternalOrTrustedSpan(evt, metadata);
-		const span = trackedSpan ?? spanWithDuration("openclaw.message.processed", spanAttrs, evt.durationMs, {
-			parentContext: internalOrTrustedExplicitParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		if (evt.outcome === "error" && evt.error) span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactSensitiveText(evt.error)
-		});
-		const traceContext = internalOrTrustedTraceContext(evt, metadata);
-		if (trackedSpan && traceContext?.spanId) {
-			completeTrackedLifecycleSpan(traceContext.spanId, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
-	};
-	const messageDeliveryAttrs = (evt) => ({
-		"openclaw.channel": lowCardinalityAttr(evt.channel),
-		"openclaw.delivery.kind": lowCardinalityAttr(evt.deliveryKind, "other")
-	});
-	const recordMessageDeliveryStarted = (evt) => {
-		messageDeliveryStartedCounter.add(1, messageDeliveryAttrs(evt));
-	};
-	const recordMessageDeliveryCompleted = (evt, metadata) => {
-		const attrs = {
-			...messageDeliveryAttrs(evt),
-			"openclaw.outcome": "completed"
-		};
-		messageDeliveryDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		spanWithDuration("openclaw.message.delivery", {
-			...attrs,
-			"openclaw.delivery.result_count": evt.resultCount
-		}, evt.durationMs, {
-			parentContext: activeInternalOrTrustedContext(evt, metadata),
-			endTimeMs: evt.ts
-		}).end(evt.ts);
-	};
-	const recordMessageDeliveryError = (evt, metadata) => {
-		const attrs = {
-			...messageDeliveryAttrs(evt),
-			"openclaw.outcome": "error",
-			"openclaw.errorCategory": lowCardinalityAttr(evt.errorCategory, "other")
-		};
-		messageDeliveryDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const span = spanWithDuration("openclaw.message.delivery", attrs, evt.durationMs, {
-			parentContext: activeInternalOrTrustedContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactSensitiveText(evt.errorCategory)
-		});
-		span.end(evt.ts);
-	};
-	const recordRunStarted = (evt, metadata) => {
-		if (!tracesEnabled || !metadata.trusted) return;
-		const spanAttrs = {};
-		addRunAttrs(spanAttrs, evt);
-		const span = trackTrustedSpan(evt, metadata, spanWithDuration("openclaw.run", spanAttrs, void 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			startTimeMs: evt.ts
-		}));
-		const parentSpanId = trustedTraceContext(evt, metadata)?.parentSpanId;
-		if (parentSpanId && !activeTrustedSpans.has(parentSpanId)) {
-			const owner = {
-				kind: "run",
-				id: evt.runId
-			};
-			activeTrustedSpanAliases.set(trustedSpanAliasKey(parentSpanId, owner), {
-				span,
-				spanId: parentSpanId,
-				owner
-			});
-		}
-	};
-	return {
-		recordModelUsage,
-		recordWebhookReceived,
-		recordWebhookProcessed,
-		recordWebhookError,
-		recordMessageQueued,
-		recordMessageReceived,
-		recordMessageDispatchStarted,
-		recordMessageDispatchCompleted,
-		recordMessageProcessed,
-		recordMessageDeliveryStarted,
-		recordMessageDeliveryCompleted,
-		recordMessageDeliveryError,
-		recordRunStarted
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-traces.ts
-function createDiagnosticsTraceRuntime(tracer) {
-	const activeTrustedSpans = /* @__PURE__ */ new Map();
-	const activeTrustedSpanAliases = /* @__PURE__ */ new Map();
-	const retainedTrustedSpanContexts = /* @__PURE__ */ new Map();
-	const retainedTrustedSpanContextCleanupTimers = /* @__PURE__ */ new Set();
-	const stopActiveTrustedSpans = () => {
-		const stopAt = Date.now();
-		for (const handle of retainedTrustedSpanContextCleanupTimers) clearTimeout(handle);
-		retainedTrustedSpanContextCleanupTimers.clear();
-		retainedTrustedSpanContexts.clear();
-		for (const span of /* @__PURE__ */ new Set([...activeTrustedSpans.values(), ...Array.from(activeTrustedSpanAliases.values(), (entry) => entry.span)])) span.end(stopAt);
-		activeTrustedSpans.clear();
-		activeTrustedSpanAliases.clear();
-	};
-	const spanWithDuration = (name, attributes, durationMs, options = {}) => {
-		const endTimeMs = options.endTimeMs ?? Date.now();
-		const startTime = typeof options.startTimeMs === "number" ? options.startTimeMs : typeof durationMs === "number" && durationMs >= 0 ? endTimeMs - durationMs : void 0;
-		const parentContext = "parentContext" in options ? options.parentContext ?? void 0 : void 0;
-		return tracer.startSpan(name, {
-			attributes: redactOtelAttributes(attributes),
-			...options.kind !== void 0 ? { kind: options.kind } : {},
-			...startTime !== void 0 ? { startTime } : {}
-		}, parentContext);
-	};
-	const trustedTraceContext = (evt, metadata) => metadata.trusted ? normalizeTraceContext(evt.trace) : void 0;
-	const internalOrTrustedTraceContext = (evt, metadata) => metadata.trusted || metadata.internal ? normalizeTraceContext(evt.trace) : void 0;
-	const trustedSpanAliasOwner = (evt) => {
-		if ("runId" in evt && evt.runId) return {
-			kind: "run",
-			id: evt.runId
-		};
-	};
-	const sameTrustedSpanAliasOwner = (left, right) => Boolean(left && right && left.kind === right.kind && left.id === right.id);
-	const trustedSpanAliasKey = (spanId, owner) => `${spanId}:${owner.kind}:${owner.id}`;
-	const retainedTrustedSpanContextKey = (traceId, spanId, owner) => `${traceId}:${owner ? trustedSpanAliasKey(spanId, owner) : spanId}`;
-	const retainedTrustedSpanContext = (traceContext, spanId, owner) => {
-		if (!traceContext?.traceId || !spanId) return;
-		const retained = (owner ? retainedTrustedSpanContexts.get(retainedTrustedSpanContextKey(traceContext.traceId, spanId, owner)) : void 0) ?? retainedTrustedSpanContexts.get(retainedTrustedSpanContextKey(traceContext.traceId, spanId));
-		if (retained?.spanContext.traceId !== traceContext.traceId) return;
-		if (retained.owner && !sameTrustedSpanAliasOwner(retained.owner, owner)) return;
-		return retained.spanContext;
-	};
-	const activeTrustedSpanAlias = (spanId, owner) => {
-		if (!owner) return;
-		const alias = activeTrustedSpanAliases.get(trustedSpanAliasKey(spanId, owner));
-		if (!alias || !sameTrustedSpanAliasOwner(alias.owner, owner)) return;
-		return alias.span;
-	};
-	const internalOrTrustedParentContext = (evt, metadata) => {
-		const traceContext = internalOrTrustedTraceContext(evt, metadata);
-		const parentSpanId = traceContext?.parentSpanId ?? traceContext?.spanId;
-		if (!traceContext || !parentSpanId) return;
-		return contextForTraceContext({
-			...traceContext,
-			spanId: parentSpanId
-		});
-	};
-	const internalOrTrustedExplicitParentContext = (evt, metadata) => {
-		const traceContext = internalOrTrustedTraceContext(evt, metadata);
-		if (!traceContext?.parentSpanId) return;
-		return contextForTraceContext({
-			...traceContext,
-			spanId: traceContext.parentSpanId
-		});
-	};
-	const activeTrustedParentContext = (evt, metadata) => {
-		const traceContext = trustedTraceContext(evt, metadata);
-		const parentSpanId = traceContext?.parentSpanId;
-		if (!parentSpanId) return;
-		const owner = trustedSpanAliasOwner(evt);
-		const spanContext = (activeTrustedSpans.get(parentSpanId) ?? activeTrustedSpanAlias(parentSpanId, owner))?.spanContext() ?? retainedTrustedSpanContext(traceContext, parentSpanId, owner);
-		if (!spanContext) return;
-		return trace.setSpanContext(context.active(), spanContext);
-	};
-	const activeInternalOrTrustedContext = (evt, metadata) => {
-		const traceContext = internalOrTrustedTraceContext(evt, metadata);
-		if (!traceContext) return;
-		const owner = trustedSpanAliasOwner(evt);
-		const activeSpan = (traceContext.spanId ? activeTrustedSpans.get(traceContext.spanId) ?? activeTrustedSpanAlias(traceContext.spanId, owner) : void 0) ?? (traceContext.parentSpanId ? activeTrustedSpans.get(traceContext.parentSpanId) ?? activeTrustedSpanAlias(traceContext.parentSpanId, owner) : void 0);
-		if (activeSpan) return trace.setSpanContext(context.active(), activeSpan.spanContext());
-		const retainedSpanContext = retainedTrustedSpanContext(traceContext, traceContext.spanId, owner) ?? retainedTrustedSpanContext(traceContext, traceContext.parentSpanId, owner);
-		if (retainedSpanContext) return trace.setSpanContext(context.active(), retainedSpanContext);
-		return internalOrTrustedParentContext(evt, metadata);
-	};
-	const trackTrustedSpan = (evt, metadata, span) => {
-		const spanId = trustedTraceContext(evt, metadata)?.spanId;
-		if (spanId) activeTrustedSpans.set(spanId, span);
-		return span;
-	};
-	const trackInternalOrTrustedSpan = (evt, metadata, span) => {
-		const spanId = internalOrTrustedTraceContext(evt, metadata)?.spanId;
-		if (spanId) activeTrustedSpans.set(spanId, span);
-		return span;
-	};
-	const takeTrackedTrustedSpan = (evt, metadata) => {
-		const spanId = trustedTraceContext(evt, metadata)?.spanId;
-		if (!spanId) return;
-		const span = activeTrustedSpans.get(spanId);
-		if (span) activeTrustedSpans.delete(spanId);
-		return span;
-	};
-	const getTrackedInternalOrTrustedSpan = (evt, metadata) => {
-		const spanId = internalOrTrustedTraceContext(evt, metadata)?.spanId;
-		if (!spanId) return;
-		return activeTrustedSpans.get(spanId);
-	};
-	const setSpanAttrs = (span, attributes) => {
-		span.setAttributes?.(redactOtelAttributes(attributes));
-	};
-	const retainTrustedSpanContext = (traceId, spanId, spanContext, retentionMarker, owner) => {
-		retainedTrustedSpanContexts.set(retainedTrustedSpanContextKey(traceId, spanId, owner), {
-			spanContext,
-			retentionMarker,
-			...owner ? { owner } : {}
-		});
-		while (retainedTrustedSpanContexts.size > MAX_RETAINED_TRUSTED_SPAN_CONTEXTS) {
-			const oldestKey = retainedTrustedSpanContexts.keys().next().value;
-			if (!oldestKey) break;
-			retainedTrustedSpanContexts.delete(oldestKey);
-		}
-	};
-	const scheduleRetainedTrustedSpanContextCleanup = (retentionMarker) => {
-		let drainHandle;
-		let timeoutHandle;
-		const cleanup = () => {
-			if (drainHandle) {
-				clearTimeout(drainHandle);
-				retainedTrustedSpanContextCleanupTimers.delete(drainHandle);
-				drainHandle = void 0;
-			}
-			if (timeoutHandle) {
-				clearTimeout(timeoutHandle);
-				retainedTrustedSpanContextCleanupTimers.delete(timeoutHandle);
-				timeoutHandle = void 0;
-			}
-			for (const [key, retained] of retainedTrustedSpanContexts) if (retained.retentionMarker === retentionMarker) retainedTrustedSpanContexts.delete(key);
-		};
-		drainHandle = setTimeout(() => {
-			if (drainHandle) {
-				retainedTrustedSpanContextCleanupTimers.delete(drainHandle);
-				drainHandle = void 0;
-			}
-			waitForDiagnosticEventsDrained().then(cleanup, cleanup);
-		}, 0);
-		drainHandle.unref?.();
-		retainedTrustedSpanContextCleanupTimers.add(drainHandle);
-		timeoutHandle = setTimeout(cleanup, RETAINED_TRUSTED_SPAN_CONTEXT_TIMEOUT_MS);
-		timeoutHandle.unref?.();
-		retainedTrustedSpanContextCleanupTimers.add(timeoutHandle);
-	};
-	const completeTrackedLifecycleSpan = (spanId, span, endTimeMs) => {
-		const spanContext = span.spanContext();
-		const retainedKeys = [{ spanId }];
-		const retainedAliasKeys = [];
-		for (const [aliasKey, alias] of activeTrustedSpanAliases) if (alias.span === span) {
-			retainedKeys.push({
-				spanId: alias.spanId,
-				owner: alias.owner
-			});
-			retainedAliasKeys.push(aliasKey);
-		}
-		if (activeTrustedSpans.get(spanId) === span) activeTrustedSpans.delete(spanId);
-		for (const aliasKey of retainedAliasKeys) if (activeTrustedSpanAliases.get(aliasKey)?.span === span) activeTrustedSpanAliases.delete(aliasKey);
-		span.end(endTimeMs);
-		const retentionMarker = Symbol("retainedTrustedSpanContext");
-		for (const retainedKey of retainedKeys) retainTrustedSpanContext(spanContext.traceId, retainedKey.spanId, spanContext, retentionMarker, retainedKey.owner);
-		scheduleRetainedTrustedSpanContextCleanup(retentionMarker);
-	};
-	const addRunAttrs = (spanAttrs, evt) => {
-		if (evt.provider) spanAttrs["openclaw.provider"] = evt.provider;
-		if (evt.model) spanAttrs["openclaw.model"] = evt.model;
-		if (evt.channel) spanAttrs["openclaw.channel"] = evt.channel;
-		if (evt.trigger) spanAttrs["openclaw.trigger"] = evt.trigger;
-	};
-	const paramsSummaryAttrs = (summary) => {
-		if (!summary) return {};
-		return {
-			"openclaw.tool.params.kind": summary.kind,
-			..."length" in summary ? { "openclaw.tool.params.length": summary.length } : {}
-		};
-	};
-	return {
-		tracer,
-		activeTrustedSpans,
-		activeTrustedSpanAliases,
-		trustedSpanAliasKey,
-		trustedSpanAliasOwner,
-		spanWithDuration,
-		trustedTraceContext,
-		internalOrTrustedTraceContext,
-		internalOrTrustedParentContext,
-		internalOrTrustedExplicitParentContext,
-		activeTrustedParentContext,
-		activeInternalOrTrustedContext,
-		trackTrustedSpan,
-		trackInternalOrTrustedSpan,
-		takeTrackedTrustedSpan,
-		getTrackedInternalOrTrustedSpan,
-		setSpanAttrs,
-		completeTrackedLifecycleSpan,
-		addRunAttrs,
-		paramsSummaryAttrs,
-		stopActiveTrustedSpans
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service.ts
-function createDiagnosticsOtelService() {
-	let sdk = null;
-	let logProvider = null;
-	let unsubscribe = null;
-	let stopActiveTrustedSpans = null;
-	let unregisterUnhandledRejectionHandler = null;
-	const stopStarted = async () => {
-		const currentUnsubscribe = unsubscribe;
-		const currentLogProvider = logProvider;
-		const currentSdk = sdk;
-		const currentStopActiveTrustedSpans = stopActiveTrustedSpans;
-		const currentUnregisterUnhandledRejectionHandler = unregisterUnhandledRejectionHandler;
-		unsubscribe = null;
-		logProvider = null;
-		sdk = null;
-		stopActiveTrustedSpans = null;
-		unregisterUnhandledRejectionHandler = null;
-		currentUnregisterUnhandledRejectionHandler?.();
-		currentUnsubscribe?.();
-		currentStopActiveTrustedSpans?.();
-		if (currentLogProvider) await currentLogProvider.shutdown().catch(() => void 0);
-		if (currentSdk) await currentSdk.shutdown().catch(() => void 0);
-	};
-	return {
-		id: "diagnostics-otel",
-		async start(ctx) {
-			await stopStarted();
-			const cfg = ctx.config.diagnostics;
-			const otel = cfg?.otel;
-			if (!cfg || cfg.enabled === false || !otel?.enabled) return;
-			const emitExporterEvent = (event) => {
-				try {
-					ctx.internalDiagnostics?.emit({
-						type: "telemetry.exporter",
-						...event
-					});
-				} catch {}
-			};
-			const emitForSignals = (signals, event) => {
-				for (const signal of signals) emitExporterEvent({
-					signal,
-					...event
-				});
-			};
-			const tracesEnabled = otel.traces !== false;
-			const metricsEnabled = otel.metrics !== false;
-			const logsEnabled = otel.logs === true;
-			const logsExporter = otel.logsExporter ?? "otlp";
-			const logsToOtlp = logsEnabled && (logsExporter === "otlp" || logsExporter === "both");
-			const logsToStdout = logsEnabled && (logsExporter === "stdout" || logsExporter === "both");
-			const otlpSignals = [
-				...tracesEnabled ? ["traces"] : [],
-				...metricsEnabled ? ["metrics"] : [],
-				...logsToOtlp ? ["logs"] : []
-			];
-			const enabledSignals = [
-				...tracesEnabled ? ["traces"] : [],
-				...metricsEnabled ? ["metrics"] : [],
-				...logsEnabled ? ["logs"] : []
-			];
-			if (enabledSignals.length === 0) return;
-			const envProtocol = process.env.OTEL_EXPORTER_OTLP_PROTOCOL;
-			const protocol = otel.protocol ?? (envProtocol?.trim() ? envProtocol : "http/protobuf");
-			if (otlpSignals.length > 0 && protocol !== "http/protobuf") {
-				emitForSignals(otlpSignals, {
-					exporter: "diagnostics-otel",
-					status: "failure",
-					reason: "unsupported_protocol"
-				});
-				ctx.logger.warn(`diagnostics-otel: unsupported protocol ${protocol}`);
-				return;
-			}
-			const endpoint = normalizeEndpoint(otel.endpoint ?? process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]);
-			const headers = otel.headers ?? void 0;
-			const serviceName = otel.serviceName?.trim() || process.env.OTEL_SERVICE_NAME || "openclaw";
-			const sampleRate = resolveSampleRate(otel.sampleRate);
-			const contentCapturePolicy = resolveContentCapturePolicy(otel.captureContent);
-			const sdkPreloaded = hasPreloadedOtelSdk();
-			const resource = resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName });
-			const logUrl = resolveSignalOtelUrl({
-				signalEndpoint: otel.logsEndpoint,
-				signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_LOGS_ENDPOINT_ENV],
-				endpoint,
-				path: "v1/logs"
-			});
-			if (!sdkPreloaded && (tracesEnabled || metricsEnabled)) {
-				const traceUrl = resolveSignalOtelUrl({
-					signalEndpoint: otel.tracesEndpoint,
-					signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_ENV],
-					endpoint,
-					path: "v1/traces"
-				});
-				const metricUrl = resolveSignalOtelUrl({
-					signalEndpoint: otel.metricsEndpoint,
-					signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_METRICS_ENDPOINT_ENV],
-					endpoint,
-					path: "v1/metrics"
-				});
-				const traceHttpAgentOptions = resolveOtelHttpAgentOptions({
-					url: traceUrl,
-					signalIdentifier: "TRACES",
-					logger: ctx.logger
-				});
-				const metricHttpAgentOptions = resolveOtelHttpAgentOptions({
-					url: metricUrl,
-					signalIdentifier: "METRICS",
-					logger: ctx.logger
-				});
-				const traceExporter = tracesEnabled ? new OTLPTraceExporter({
-					...traceUrl ? { url: traceUrl } : {},
-					...headers ? { headers } : {},
-					...traceHttpAgentOptions ? { httpAgentOptions: traceHttpAgentOptions } : {}
-				}) : void 0;
-				const spanProcessors = traceExporter && typeof otel.flushIntervalMs === "number" ? [new BatchSpanProcessor(traceExporter, { scheduledDelayMillis: Math.max(1e3, otel.flushIntervalMs) })] : void 0;
-				const metricExporter = metricsEnabled ? new OTLPMetricExporter({
-					...metricUrl ? { url: metricUrl } : {},
-					...headers ? { headers } : {},
-					...metricHttpAgentOptions ? { httpAgentOptions: metricHttpAgentOptions } : {}
-				}) : void 0;
-				const metricReader = metricExporter ? new PeriodicExportingMetricReader({
-					exporter: metricExporter,
-					...typeof otel.flushIntervalMs === "number" ? { exportIntervalMillis: Math.max(1e3, otel.flushIntervalMs) } : {}
-				}) : void 0;
-				sdk = new NodeSDK({
-					resource,
-					...spanProcessors ? { spanProcessors } : traceExporter ? { traceExporter } : {},
-					...metricReader ? { metricReader } : {},
-					...sampleRate !== void 0 ? { sampler: new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(sampleRate) }) } : {}
-				});
-				try {
-					sdk.start();
-				} catch (err) {
-					emitForSignals([...tracesEnabled ? ["traces"] : [], ...metricsEnabled ? ["metrics"] : []], {
-						exporter: "diagnostics-otel",
-						status: "failure",
-						reason: "start_failed",
-						errorCategory: errorCategory(err)
-					});
-					await stopStarted();
-					ctx.logger.error(`diagnostics-otel: failed to start SDK: ${formatError(err)}`);
-					throw err;
-				}
-			} else if (sdkPreloaded && (tracesEnabled || metricsEnabled)) ctx.logger.info("diagnostics-otel: using preloaded OpenTelemetry SDK");
-			const meter = metrics.getMeter("openclaw");
-			const diagnosticsTrace = createDiagnosticsTraceRuntime(trace.getTracer("openclaw"));
-			stopActiveTrustedSpans = diagnosticsTrace.stopActiveTrustedSpans;
-			const diagnosticMetrics = createDiagnosticsMetrics(meter);
-			const diagnosticsLogs = createDiagnosticsLogExporter({
-				contentCapturePolicy,
-				emitExporterEvent,
-				flushIntervalMs: otel.flushIntervalMs,
-				headers,
-				logger: ctx.logger,
-				logsEnabled,
-				logsToOtlp,
-				logsToStdout,
-				logUrl,
-				resource,
-				serviceName
-			});
-			logProvider = diagnosticsLogs.logProvider;
-			const { recordLogRecord, recordSecurityEvent } = diagnosticsLogs;
-			const recorderRuntime = createDiagnosticsRecorderRuntime({
-				contentCapturePolicy,
-				metrics: diagnosticMetrics,
-				traces: diagnosticsTrace,
-				tracesEnabled
-			});
-			const recorders = {
-				...createUsageRecorders(recorderRuntime),
-				...createOperationsRecorders(recorderRuntime),
-				...createHarnessRecorders(recorderRuntime),
-				...createModelRecorders(recorderRuntime),
-				...createToolAndSystemRecorders(recorderRuntime)
-			};
-			const subscribe = ctx.internalDiagnostics?.onEvent;
-			if (!subscribe) {
-				ctx.logger.error("diagnostics-otel: internal diagnostics capability unavailable");
-				return;
-			}
-			unsubscribe = subscribe(createDiagnosticsEventHandler({
-				logger: ctx.logger,
-				recorders,
-				recordLogRecord,
-				recordSecurityEvent
-			}));
-			unregisterUnhandledRejectionHandler = registerUnhandledRejectionHandler((reason) => {
-				const otlpError = findOtlpExporterError(reason);
-				if (!otlpError) return false;
-				const code = readErrorCode(otlpError) ?? "unknown";
-				ctx.logger.warn(`diagnostics-otel: suppressed OTLP exporter unhandled rejection (code=${String(code)})`);
-				return true;
-			});
-			emitForSignals(enabledSignals, {
-				exporter: "diagnostics-otel",
-				status: "started",
-				reason: "configured"
-			});
-			if (logsEnabled) {
-				const label = logsExporter === "both" ? "OTLP/Protobuf + stdout JSONL" : logsExporter === "stdout" ? "stdout JSONL" : "OTLP/Protobuf";
-				ctx.logger.info(`diagnostics-otel: logs exporter enabled (${label})`);
-			}
-		},
-		async stop() {
-			await stopStarted();
-		}
-	};
-}
-//#endregion
-export { createDiagnosticsOtelService as t };