@latitude-data/openclaw-telemetry 0.0.3 → 0.0.5

package/dist/plugin.js

@@ -1,5 +1,8 @@
-import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { arch, hostname, platform, release } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/client.ts
 async function postTraces({ baseUrl, apiKey, project, payload, logger, timeoutMs = 1e4 }) {
 	const url = `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
@@ -74,10 +77,10 @@ function createLogger(debugEnabled) {
 //#endregion
 //#region src/otlp.ts
 const SCOPE_NAME = "@latitude-data/openclaw-telemetry";
-const SCOPE_VERSION = "0.0.2";
+const SCOPE_VERSION = readScopeVersion();
 /** Build an OTLP export request for a single completed agent run. */
-function buildOtlpRequest(run, options) {
-	const spans = buildRunSpans(run, options);
+function buildOtlpRequest(result, options) {
+	const spans = result.spans.map((span) => toOtlpSpan(span, options));
 	return { resourceSpans: [{
 		resource: { attributes: resourceAttrs() },
 		scopeSpans: [{
@@ -89,210 +92,158 @@ function buildOtlpRequest(run, options) {
 		}]
 	}] };
 }
-function buildRunSpans(run, options) {
-	const traceId = hashHex(`${run.sessionId ?? "session"}:${run.runId}`, 32);
-	const interactionSpanId = hashHex(`${traceId}:run`, 16);
-	const out = [buildInteractionSpan(traceId, interactionSpanId, run, options)];
-	run.llmCalls.forEach((call, idx) => {
-		const callSpanId = hashHex(`${traceId}:call:${idx}`, 16);
-		out.push(buildLlmSpan(traceId, interactionSpanId, callSpanId, call, idx, run, options));
-		call.toolCalls.forEach((tool, tIdx) => {
-			const toolSpanId = hashHex(`${traceId}:call:${idx}:tool:${tIdx}`, 16);
-			out.push(buildToolSpan(traceId, interactionSpanId, toolSpanId, tool, run, options));
-		});
-	});
-	run.orphanTools.forEach((tool, idx) => {
-		const toolSpanId = hashHex(`${traceId}:orphan-tool:${idx}`, 16);
-		out.push(buildToolSpan(traceId, interactionSpanId, toolSpanId, tool, run, options));
-	});
-	return out;
-}
-function buildInteractionSpan(traceId, spanId, run, options) {
-	const startNs = msToNs(run.startMs);
-	const endNs = msToNs(run.endMs ?? run.startMs);
-	const totalTools = run.llmCalls.reduce((sum, c) => sum + c.toolCalls.length, 0) + run.orphanTools.length;
-	const totalUsage = aggregateUsage(run.llmCalls);
+function toOtlpSpan(span, options) {
+	const startNs = msToNs(span.startMs);
+	const endNs = msToNs(span.endMs ?? span.startMs);
+	const attrs = [];
+	for (const [rawKey, value] of Object.entries(span.attrs)) {
+		if (value === void 0 || value === null) continue;
+		const isGated = rawKey.endsWith(":gated");
+		if (isGated && !options.allowConversationAccess) continue;
+		const kv = encodeAttr(isGated ? rawKey.slice(0, -6) : rawKey, value);
+		if (kv !== void 0) attrs.push(kv);
+	}
+	attrs.push(bool("latitude.captured.content", options.allowConversationAccess));
+	if (span.endMs !== void 0) attrs.push(int("openclaw.duration_ms.computed", Math.max(0, span.endMs - span.startMs)));
+	const statusCode = span.outcome === "error" ? 2 : 1;
 	return {
-		traceId,
-		spanId,
-		parentSpanId: "",
-		name: "interaction",
+		traceId: span.traceId,
+		spanId: span.spanId,
+		parentSpanId: span.parentSpanId,
+		name: span.name,
 		kind: 1,
 		startTimeUnixNano: startNs,
 		endTimeUnixNano: endNs,
-		attributes: stripUndef([
-			str("span.type", "interaction"),
-			str("interaction.kind", "agent_run"),
-			str("openclaw.run.id", run.runId),
-			run.sessionId ? str("openclaw.session.id", run.sessionId) : void 0,
-			run.sessionId ? str("session.id", run.sessionId) : void 0,
-			run.sessionKey ? str("openclaw.session.key", run.sessionKey) : void 0,
-			run.agentId ? str("openclaw.agent.id", run.agentId) : void 0,
-			run.agentId ? str("openclaw.agent.name", run.agentId) : void 0,
-			run.workspaceDir ? str("openclaw.workspace.dir", run.workspaceDir) : void 0,
-			run.messageProvider ? str("openclaw.message.provider", run.messageProvider) : void 0,
-			run.channelId ? str("openclaw.channel.id", run.channelId) : void 0,
-			run.trigger ? str("openclaw.trigger", run.trigger) : void 0,
-			run.modelProviderId ? str("openclaw.model.provider.id", run.modelProviderId) : void 0,
-			run.modelId ? str("openclaw.model.id", run.modelId) : void 0,
-			int("interaction.duration_ms", durationMs(run.startMs, run.endMs)),
-			int("interaction.call_count", run.llmCalls.length),
-			int("interaction.tool_call_count", totalTools),
-			run.success !== void 0 ? bool("openclaw.run.success", run.success) : void 0,
-			run.error ? str("openclaw.run.error", run.error) : void 0,
-			totalUsage.input !== void 0 ? int("gen_ai.usage.input_tokens", totalUsage.input) : void 0,
-			totalUsage.output !== void 0 ? int("gen_ai.usage.output_tokens", totalUsage.output) : void 0,
-			totalUsage.cacheRead !== void 0 ? int("gen_ai.usage.cache_read_input_tokens", totalUsage.cacheRead) : void 0,
-			totalUsage.cacheWrite !== void 0 ? int("gen_ai.usage.cache_creation_input_tokens", totalUsage.cacheWrite) : void 0,
-			totalUsage.total !== void 0 ? int("gen_ai.usage.total_tokens", totalUsage.total) : void 0,
-			options.allowConversationAccess && run.llmCalls[0]?.prompt ? str("user_prompt", run.llmCalls[0].prompt) : void 0,
-			bool("latitude.captured.content", options.allowConversationAccess)
-		]),
-		status: { code: run.success === false ? 2 : 1 }
+		attributes: attrs,
+		status: { code: statusCode }
 	};
 }
-function buildLlmSpan(traceId, parentSpanId, spanId, call, callIdx, run, options) {
-	const startNs = msToNs(call.startMs);
-	const endNs = msToNs(call.endMs ?? call.startMs);
-	const captureContent = options.allowConversationAccess;
-	const inputMessages = captureContent ? buildInputMessages(call) : void 0;
-	const outputMessages = captureContent ? buildOutputMessages(call) : void 0;
-	const systemInstructions = captureContent && call.systemPrompt ? JSON.stringify([{
-		type: "text",
-		content: call.systemPrompt
-	}]) : void 0;
+function encodeAttr(key, value) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "string") return str(key, value);
+	if (typeof value === "boolean") return bool(key, value);
+	if (typeof value === "number") return Number.isInteger(value) ? int(key, value) : {
+		key,
+		value: { doubleValue: value }
+	};
+	return str(key, safeJson$1(value));
+}
+function resourceAttrs() {
+	return [
+		str("service.name", "openclaw"),
+		str("service.version", SCOPE_VERSION),
+		str("host.name", hostname()),
+		str("host.arch", arch()),
+		str("os.type", platform()),
+		str("os.version", release())
+	];
+}
+function str(key, value) {
 	return {
-		traceId,
-		spanId,
-		parentSpanId,
-		name: "llm_request",
-		kind: 3,
-		startTimeUnixNano: startNs,
-		endTimeUnixNano: endNs,
-		attributes: stripUndef([
-			str("span.type", "llm_request"),
-			str("gen_ai.operation.name", "chat"),
-			str("llm_request.context", "interaction"),
-			int("llm_request.call_index", callIdx),
-			str("gen_ai.system", call.provider),
-			str("openclaw.provider", call.provider),
-			str("gen_ai.request.model", call.requestModel),
-			str("model", call.requestModel),
-			call.responseModel ? str("gen_ai.response.model", call.responseModel) : void 0,
-			call.resolvedRef ? str("openclaw.resolved.ref", call.resolvedRef) : void 0,
-			run.sessionId ? str("session.id", run.sessionId) : void 0,
-			run.sessionKey ? str("openclaw.session.key", run.sessionKey) : void 0,
-			str("openclaw.run.id", call.runId),
-			call.agentId ? str("openclaw.agent.id", call.agentId) : void 0,
-			call.agentId ? str("openclaw.agent.name", call.agentId) : void 0,
-			call.usage?.input !== void 0 ? int("gen_ai.usage.input_tokens", call.usage.input) : void 0,
-			call.usage?.input !== void 0 ? int("input_tokens", call.usage.input) : void 0,
-			call.usage?.output !== void 0 ? int("gen_ai.usage.output_tokens", call.usage.output) : void 0,
-			call.usage?.output !== void 0 ? int("output_tokens", call.usage.output) : void 0,
-			call.usage?.cacheRead !== void 0 ? int("gen_ai.usage.cache_read_input_tokens", call.usage.cacheRead) : void 0,
-			call.usage?.cacheRead !== void 0 ? int("cache_read_tokens", call.usage.cacheRead) : void 0,
-			call.usage?.cacheWrite !== void 0 ? int("gen_ai.usage.cache_creation_input_tokens", call.usage.cacheWrite) : void 0,
-			call.usage?.cacheWrite !== void 0 ? int("cache_creation_tokens", call.usage.cacheWrite) : void 0,
-			call.usage?.total !== void 0 ? int("gen_ai.usage.total_tokens", call.usage.total) : void 0,
-			systemInstructions ? str("gen_ai.system_instructions", systemInstructions) : void 0,
-			inputMessages ? str("gen_ai.input.messages", JSON.stringify(inputMessages)) : void 0,
-			outputMessages ? str("gen_ai.output.messages", JSON.stringify(outputMessages)) : void 0,
-			bool("latitude.captured.content", captureContent),
-			int("openclaw.images.count", call.imagesCount),
-			int("llm_request.tool_call_count", call.toolCalls.length),
-			int("llm_request.duration_ms", durationMs(call.startMs, call.endMs)),
-			call.error ? str("error.type", "llm_error") : void 0,
-			call.error ? str("error.message", call.error) : void 0,
-			str("success", call.error ? "false" : "true"),
-			str("llm_request.captured", "true")
-		]),
-		status: { code: call.error ? 2 : 1 }
+		key,
+		value: { stringValue: value }
 	};
 }
-function buildToolSpan(traceId, parentSpanId, spanId, tool, run, options) {
-	const startNs = msToNs(tool.startMs);
-	const endNs = msToNs(tool.endMs ?? tool.startMs);
-	const isError = Boolean(tool.error);
-	const captureContent = options.allowConversationAccess;
+function int(key, value) {
 	return {
-		traceId,
-		spanId,
-		parentSpanId,
-		name: `tool:${tool.toolName}`,
-		kind: 1,
-		startTimeUnixNano: startNs,
-		endTimeUnixNano: endNs,
-		attributes: stripUndef([
-			str("span.type", "tool_execution"),
-			str("gen_ai.operation.name", "execute_tool"),
-			str("gen_ai.tool.name", tool.toolName),
-			str("gen_ai.tool.call.id", tool.toolCallId),
-			captureContent ? str("gen_ai.tool.call.arguments", safeJson(tool.params)) : void 0,
-			captureContent && tool.result !== void 0 ? str("gen_ai.tool.call.result", safeJson(tool.result)) : void 0,
-			bool("latitude.captured.content", captureContent),
-			isError ? str("error.type", "tool_error") : void 0,
-			isError ? str("error.message", tool.error ?? "") : void 0,
-			bool("tool.is_error", isError),
-			str("success", isError ? "false" : "true"),
-			tool.durationMs !== void 0 ? int("tool.duration_ms", tool.durationMs) : void 0,
-			run.sessionId ? str("session.id", run.sessionId) : void 0,
-			run.sessionKey ? str("openclaw.session.key", run.sessionKey) : void 0,
-			str("openclaw.run.id", run.runId),
-			tool.agentId ? str("openclaw.agent.id", tool.agentId) : void 0,
-			tool.agentId ? str("openclaw.agent.name", tool.agentId) : void 0
-		]),
-		status: { code: isError ? 2 : 1 }
+		key,
+		value: { intValue: String(Math.trunc(value)) }
 	};
 }
-function buildInputMessages(call) {
-	const out = [];
-	for (const msg of call.historyMessages) {
-		const normalized = normalizeHistoryMessage(msg);
-		if (normalized) out.push(normalized);
+function bool(key, value) {
+	return {
+		key,
+		value: { boolValue: value }
+	};
+}
+function msToNs(ms) {
+	return (BigInt(Math.trunc(ms)) * 1000000n).toString();
+}
+function safeJson$1(value) {
+	try {
+		if (typeof value === "string") return value;
+		return JSON.stringify(value);
+	} catch {
+		return "";
 	}
-	if (call.prompt.length > 0) out.push({
-		role: "user",
-		parts: [{
-			type: "text",
-			content: call.prompt
-		}]
-	});
-	return out;
 }
+/**
+* Runtime-read package version, so OTLP `scope.version` and `service.version`
+* always reflect what's actually installed. Read once at module load and
+* cached. Falls back to `"unknown"` if the read fails.
+*
+* Same import.meta.url + ../package.json pattern used by `cli.ts` for the
+* `--version` flag — single source of truth in package.json.
+*/
+function readScopeVersion() {
+	try {
+		const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+		return JSON.parse(readFileSync(pkgPath, "utf-8")).version ?? "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+//#endregion
+//#region src/messages.ts
 const ALLOWED_ROLES = new Set([
 	"system",
 	"user",
 	"assistant",
 	"tool"
 ]);
-function normalizeRole(raw) {
-	if (typeof raw !== "string") return "user";
-	return ALLOWED_ROLES.has(raw) ? raw : "user";
-}
-function normalizeHistoryMessage(raw) {
+/**
+* Normalize a single message of any of the provider shapes we know about.
+* Returns `undefined` for non-objects so the caller can skip them.
+*/
+function normalizeMessage(raw) {
 	if (!raw || typeof raw !== "object") return void 0;
 	const obj = raw;
-	const role = normalizeRole(obj.role);
+	const role = coerceRole(obj.role);
+	if (Array.isArray(obj.parts)) {
+		const parts = [];
+		for (const p of obj.parts) if (p && typeof p === "object") parts.push(p);
+		return {
+			role,
+			parts: parts.length > 0 ? parts : [{
+				type: "text",
+				content: safeJson(raw)
+			}]
+		};
+	}
 	const content = obj.content ?? obj.text ?? obj.message;
-	if (typeof content === "string") return {
+	if (role === "tool" && obj.tool_call_id !== void 0) return {
 		role,
 		parts: [{
-			type: "text",
-			content
+			type: "tool_call_response",
+			id: typeof obj.tool_call_id === "string" ? obj.tool_call_id : "",
+			response: content ?? safeJson(obj)
 		}]
 	};
+	if (typeof content === "string") {
+		const parts = [{
+			type: "text",
+			content
+		}];
+		appendToolCalls(parts, obj.tool_calls);
+		return {
+			role,
+			parts
+		};
+	}
 	if (Array.isArray(content)) {
 		const parts = [];
 		for (const block of content) {
-			const part = normalizeContentBlock(block);
+			const part = normalizeBlock(block);
 			if (part) parts.push(part);
 		}
+		appendToolCalls(parts, obj.tool_calls);
+		if (parts.length === 0) parts.push({
+			type: "text",
+			content: safeJson(content)
+		});
 		return {
 			role,
-			parts: parts.length > 0 ? parts : [{
-				type: "text",
-				content: JSON.stringify(content)
-			}]
+			parts
 		};
 	}
 	return {
@@ -303,13 +254,76 @@ function normalizeHistoryMessage(raw) {
 		}]
 	};
 }
-function normalizeContentBlock(raw) {
+/** Normalize an array of provider messages. */
+function normalizeMessages(raw) {
+	const out = [];
+	for (const m of raw) {
+		const norm = normalizeMessage(m);
+		if (norm) out.push(norm);
+	}
+	return out;
+}
+/** Build a single user message from a string prompt. */
+function userMessageFromPrompt(prompt) {
+	return {
+		role: "user",
+		parts: [{
+			type: "text",
+			content: prompt
+		}]
+	};
+}
+/** Build a single assistant message from `assistantTexts` + `lastAssistant` fallback. */
+function assistantMessageFromOutput(assistantTexts, lastAssistant) {
+	if (lastAssistant !== void 0) {
+		const norm = normalizeMessage(lastAssistant);
+		if (norm) return {
+			...norm,
+			role: "assistant"
+		};
+	}
+	const parts = [];
+	for (const text of assistantTexts) if (text.length > 0) parts.push({
+		type: "text",
+		content: text
+	});
+	if (parts.length === 0) parts.push({
+		type: "text",
+		content: ""
+	});
+	return {
+		role: "assistant",
+		parts
+	};
+}
+/**
+* Wrap a system prompt string into the parts-array shape expected for
+* `gen_ai.system_instructions`. Empty string in → single empty text part out
+* (still a valid array, never `undefined`).
+*/
+function systemInstructionsParts(prompt) {
+	return [{
+		type: "text",
+		content: prompt
+	}];
+}
+function coerceRole(raw) {
+	if (typeof raw !== "string") return "user";
+	return ALLOWED_ROLES.has(raw) ? raw : "user";
+}
+function normalizeBlock(raw) {
 	if (typeof raw === "string") return {
 		type: "text",
 		content: raw
 	};
 	if (!raw || typeof raw !== "object") return void 0;
 	const obj = raw;
+	if (typeof obj.type === "string" && (typeof obj.content === "string" || obj.content === void 0)) {
+		if (obj.type === "text" && typeof obj.content === "string") return {
+			type: "text",
+			content: obj.content
+		};
+	}
 	const type = typeof obj.type === "string" ? obj.type : "text";
 	if (type === "text" && typeof obj.text === "string") return {
 		type: "text",
@@ -321,104 +335,66 @@ function normalizeContentBlock(raw) {
 		name: typeof obj.name === "string" ? obj.name : "",
 		arguments: obj.input ?? {}
 	};
+	if (type === "tool_call") return {
+		type: "tool_call",
+		id: typeof obj.id === "string" ? obj.id : "",
+		name: typeof obj.name === "string" ? obj.name : "",
+		arguments: obj.arguments ?? obj.input ?? {}
+	};
 	if (type === "tool_result") return {
 		type: "tool_call_response",
 		id: typeof obj.tool_use_id === "string" ? obj.tool_use_id : "",
 		response: obj.content ?? ""
 	};
-	if (type === "image") return {
-		type: "uri",
-		modality: "image",
-		uri: safeJson(obj.source ?? obj)
+	if (type === "tool_call_response") return {
+		type: "tool_call_response",
+		id: typeof obj.id === "string" ? obj.id : "",
+		response: obj.response ?? ""
 	};
-	return {
-		type,
-		content: safeJson(raw)
+	if (type === "thinking" && typeof obj.thinking === "string") return {
+		type: "reasoning",
+		content: obj.thinking
 	};
-}
-function buildOutputMessages(call) {
-	const parts = [];
-	for (const text of call.assistantTexts) if (text.length > 0) parts.push({
-		type: "text",
-		content: text
-	});
-	for (const tool of call.toolCalls) parts.push({
-		type: "tool_call",
-		id: tool.toolCallId,
-		name: tool.toolName,
-		arguments: tool.params
-	});
-	if (parts.length === 0 && call.lastAssistant !== void 0) parts.push({
-		type: "text",
-		content: safeJson(call.lastAssistant)
-	});
-	return [{
-		role: "assistant",
-		parts
-	}];
-}
-function aggregateUsage(calls) {
-	const agg = {
-		input: void 0,
-		output: void 0,
-		cacheRead: void 0,
-		cacheWrite: void 0,
-		total: void 0
+	if (type === "reasoning" && typeof obj.content === "string") return {
+		type: "reasoning",
+		content: obj.content
 	};
-	const add = (k, v) => {
-		if (v === void 0) return;
-		agg[k] = (agg[k] ?? 0) + v;
-	};
-	for (const c of calls) {
-		if (!c.usage) continue;
-		add("input", c.usage.input);
-		add("output", c.usage.output);
-		add("cacheRead", c.usage.cacheRead);
-		add("cacheWrite", c.usage.cacheWrite);
-		add("total", c.usage.total);
+	if (type === "image" && obj.source && typeof obj.source === "object") {
+		const src = obj.source;
+		const uri = src.url ?? (src.data ? `data:${src.media_type ?? "image/unknown"};base64,${src.data}` : "");
+		if (uri) return {
+			type: "uri",
+			modality: "image",
+			uri
+		};
 	}
-	return agg;
-}
-function resourceAttrs() {
-	return [
-		str("service.name", "openclaw"),
-		str("service.version", SCOPE_VERSION),
-		str("host.name", hostname()),
-		str("host.arch", arch()),
-		str("os.type", platform()),
-		str("os.version", release())
-	];
-}
-function str(key, value) {
 	return {
-		key,
-		value: { stringValue: value }
-	};
-}
-function int(key, value) {
-	return {
-		key,
-		value: { intValue: String(Math.trunc(value)) }
-	};
-}
-function bool(key, value) {
-	return {
-		key,
-		value: { boolValue: value }
+		type,
+		content: safeJson(raw)
 	};
 }
-function stripUndef(items) {
-	return items.filter((x) => x !== void 0);
-}
-function hashHex(input, length) {
-	return createHash("sha256").update(input).digest("hex").slice(0, length);
-}
-function msToNs(ms) {
-	return (BigInt(Math.trunc(ms)) * 1000000n).toString();
-}
-function durationMs(startMs, endMs) {
-	if (endMs === void 0) return 0;
-	return Math.max(0, endMs - startMs);
+/**
+* OpenAI assistant messages put tool calls in a separate `tool_calls` array
+* alongside string content. Append them as parts so the trace shows what the
+* model emitted in that turn.
+*/
+function appendToolCalls(parts, raw) {
+	if (!Array.isArray(raw)) return;
+	for (const tc of raw) {
+		if (!tc || typeof tc !== "object") continue;
+		const t = tc;
+		const fn = t.function;
+		let parsedArgs = fn?.arguments;
+		if (typeof parsedArgs === "string") try {
+			parsedArgs = JSON.parse(parsedArgs);
+		} catch {}
+		parts.push({
+			type: "tool_call",
+			id: typeof t.id === "string" ? t.id : "",
+			name: fn?.name ?? "",
+			arguments: parsedArgs ?? {}
+		});
+	}
 }
 function safeJson(value) {
 	try {
@@ -429,179 +405,484 @@ function safeJson(value) {
 	}
 }
 //#endregion
-//#region src/turn-builder.ts
-/**
-* Accumulates OpenClaw hook events per agent run (keyed by `runId`) into a
-* `RunRecord` ready to be converted to OTLP spans. All mutation is synchronous
-* and non-blocking so the hook runner can stay fire-and-forget.
-*
-* Event ordering assumptions (verified against OpenClaw
-* src/agents/pi-embedded-runner/run/attempt.ts):
-*
-*   session_start? -> [ llm_input -> (before_tool_call -> after_tool_call)* -> llm_output ]+ -> agent_end
-*
-* Tool calls arriving between an `llm_input` and its `llm_output` are attached
-* to the currently-open LLM call. Tools arriving outside that window (e.g.
-* `after_tool_call` fires after `llm_output` has already closed the call) are
-* stored on the run's `orphanTools` list so we don't drop them.
-*/
-var TurnBuilder = class {
+//#region src/span-builder.ts
+const SUBAGENT_LINK_TTL_MS = 3600 * 1e3;
+const SUBAGENT_LINK_MAX = 1e3;
+var SpanBuilder = class {
 	runs = /* @__PURE__ */ new Map();
-	onSessionStart(_evt, _ctx) {}
+	subagentLinks = /* @__PURE__ */ new Map();
+	inflightCount() {
+		return this.runs.size;
+	}
+	/**
+	* Open the root `agent` span. If the runId was previously registered as a
+	* subagent's child, propagate the parent's traceId and parent the new span
+	* under the parent's `subagent` span — so the entire subagent's work nests
+	* inside the parent's trace as one waterfall.
+	*/
+	onBeforeAgentStart(evt, ctx) {
+		const runId = ctx.runId;
+		if (!runId) return;
+		if (this.runs.has(runId)) return;
+		const link = this.subagentLinks.get(runId);
+		const traceId = link?.traceId ?? hashHex(runId, 32);
+		const parentSpanId = link?.subagentSpanId ?? "";
+		const agent = {
+			spanId: hashHex(`${traceId}:${runId}:agent`, 16),
+			traceId,
+			parentSpanId,
+			name: "agent",
+			startMs: Date.now(),
+			endMs: void 0,
+			attrs: {
+				...flattenCtx(ctx),
+				...latitudeAttrs(ctx),
+				"openclaw.run.id": runId,
+				"before_agent_start.prompt:gated": evt.prompt,
+				"before_agent_start.messages:gated": evt.messages ? normalizeMessages(evt.messages) : void 0
+			}
+		};
+		this.runs.set(runId, {
+			agent,
+			history: [],
+			openModelCalls: /* @__PURE__ */ new Map(),
+			openToolCalls: /* @__PURE__ */ new Map(),
+			openCompaction: void 0,
+			closed: [],
+			childSubagentSpans: /* @__PURE__ */ new Map()
+		});
+	}
+	/**
+	* Enrich the open `agent` span with content + identity from the LLM input.
+	* Also seeds the rolling history snapshot used by per-call `model_call`
+	* input attributes.
+	*
+	* Provider-specific message shapes get normalized into the parts-based
+	* GenAI format here — that's the contract Latitude's downstream parser
+	* expects on `gen_ai.input.messages` and `gen_ai.system_instructions`.
+	*/
 	onLlmInput(evt, ctx) {
-		const run = this.ensureRun(evt.runId, ctx);
-		const call = {
-			runId: evt.runId,
-			sessionId: evt.sessionId,
-			sessionKey: ctx.sessionKey,
-			agentId: ctx.agentId,
-			provider: evt.provider,
-			requestModel: evt.model,
-			responseModel: void 0,
-			resolvedRef: void 0,
-			systemPrompt: evt.systemPrompt,
-			prompt: evt.prompt,
-			historyMessages: evt.historyMessages,
-			imagesCount: evt.imagesCount,
-			assistantTexts: [],
-			lastAssistant: void 0,
-			usage: void 0,
+		const run = this.runs.get(ctx.runId ?? evt.runId);
+		if (!run) return;
+		const inputMessages = [...normalizeMessages(evt.historyMessages)];
+		if (evt.prompt) inputMessages.push(userMessageFromPrompt(evt.prompt));
+		Object.assign(run.agent.attrs, {
+			"gen_ai.system_instructions:gated": evt.systemPrompt ? systemInstructionsParts(evt.systemPrompt) : void 0,
+			"user_prompt:gated": evt.prompt,
+			"gen_ai.input.messages:gated": inputMessages,
+			"openclaw.images.count": evt.imagesCount,
+			"gen_ai.request.model": evt.model,
+			"gen_ai.system": evt.provider,
+			"openclaw.provider": evt.provider
+		});
+		run.history = inputMessages;
+	}
+	/**
+	* Enrich the agent span with attempt-aggregate output + token usage.
+	* (Per-call usage isn't surfaced by OpenClaw today — see PR #2986.)
+	*/
+	onLlmOutput(evt, ctx) {
+		const run = this.runs.get(ctx.runId ?? evt.runId);
+		if (!run) return;
+		const assistantMessage = assistantMessageFromOutput(evt.assistantTexts, evt.lastAssistant);
+		Object.assign(run.agent.attrs, {
+			"gen_ai.output.messages:gated": [assistantMessage],
+			"openclaw.resolved.ref": evt.resolvedRef,
+			"openclaw.harness.id": evt.harnessId,
+			"gen_ai.response.model": evt.model,
+			...usageAttrs(evt.usage)
+		});
+	}
+	onModelCallStarted(evt, ctx) {
+		const run = this.runs.get(evt.runId);
+		if (!run) return;
+		const span = {
+			spanId: hashHex(`${run.agent.traceId}:model_call:${evt.callId}`, 16),
+			traceId: run.agent.traceId,
+			parentSpanId: run.agent.spanId,
+			name: "model_call",
 			startMs: Date.now(),
 			endMs: void 0,
-			error: void 0,
-			toolCalls: []
+			attrs: {
+				...latitudeAttrs(ctx),
+				"openclaw.run.id": evt.runId,
+				"openclaw.call.id": evt.callId,
+				"gen_ai.system": evt.provider,
+				"openclaw.provider": evt.provider,
+				"gen_ai.request.model": evt.model,
+				"openclaw.api": evt.api,
+				"openclaw.transport": evt.transport,
+				"gen_ai.input.messages:gated": [...run.history]
+			}
 		};
-		run.llmCalls.push(call);
-		return call;
+		run.openModelCalls.set(evt.callId, span);
+	}
+	onModelCallEnded(evt, _ctx) {
+		const run = this.runs.get(evt.runId);
+		if (!run) return;
+		const span = run.openModelCalls.get(evt.callId);
+		if (!span) return;
+		span.endMs = Date.now();
+		span.outcome = evt.outcome === "completed" ? "ok" : "error";
+		span.errorMessage = evt.errorCategory;
+		Object.assign(span.attrs, {
+			"openclaw.duration_ms": evt.durationMs,
+			"openclaw.outcome": evt.outcome,
+			"openclaw.error.category": evt.errorCategory,
+			"openclaw.failure.kind": evt.failureKind,
+			"openclaw.request.payload_bytes": evt.requestPayloadBytes,
+			"openclaw.response.stream_bytes": evt.responseStreamBytes,
+			"openclaw.ttfb_ms": evt.timeToFirstByteMs,
+			"openclaw.upstream.request_id_hash": evt.upstreamRequestIdHash
+		});
+		run.openModelCalls.delete(evt.callId);
+		run.closed.push(span);
 	}
+	/**
+	* Open a `tool_call` span as a sibling of the agent span. Also append a
+	* synthetic assistant `tool_call` part to the rolling history so the NEXT
+	* model_call's input snapshot reflects what the model emitted.
+	*
+	* IMPORTANT: this runs as a `runModifyingHook` in OpenClaw — returning
+	* anything other than `undefined`/falsy from this handler blocks the tool.
+	* The plugin-side handler enforces a void return; this method's signature
+	* already returns `void`.
+	*/
 	onBeforeToolCall(evt, ctx) {
 		if (!evt.runId) return;
-		const run = this.runs.get(evt.runId) ?? this.ensureRun(evt.runId, ctx);
-		const tool = {
-			toolCallId: evt.toolCallId ?? `${evt.toolName}:${randomUUID()}`,
-			toolName: evt.toolName,
-			params: evt.params,
-			result: void 0,
-			error: void 0,
+		const run = this.runs.get(evt.runId);
+		if (!run) return;
+		const toolCallId = evt.toolCallId ?? `${evt.toolName}:${randomUUID()}`;
+		const span = {
+			spanId: hashHex(`${run.agent.traceId}:tool_call:${toolCallId}`, 16),
+			traceId: run.agent.traceId,
+			parentSpanId: run.agent.spanId,
+			name: `tool_call:${evt.toolName}`,
 			startMs: Date.now(),
 			endMs: void 0,
-			durationMs: void 0,
-			agentId: ctx.agentId
+			attrs: {
+				...latitudeAttrs(ctx),
+				"openclaw.run.id": evt.runId,
+				"gen_ai.tool.name": evt.toolName,
+				"gen_ai.tool.call.id": toolCallId,
+				"gen_ai.tool.call.arguments:gated": evt.params
+			}
 		};
-		const openCall = this.currentOpenCall(run);
-		if (openCall) openCall.toolCalls.push(tool);
-		else run.orphanTools.push(tool);
+		run.openToolCalls.set(toolCallId, span);
+		run.history.push({
+			role: "assistant",
+			parts: [{
+				type: "tool_call",
+				id: toolCallId,
+				name: evt.toolName,
+				arguments: evt.params
+			}]
+		});
 	}
 	onAfterToolCall(evt, _ctx) {
 		if (!evt.runId) return;
 		const run = this.runs.get(evt.runId);
 		if (!run) return;
-		const tool = this.findToolRecord(run, evt.toolCallId, evt.toolName);
-		if (!tool) return;
-		tool.result = evt.result;
-		tool.error = evt.error;
-		tool.durationMs = evt.durationMs;
-		tool.endMs = Date.now();
+		let resolvedId = evt.toolCallId && run.openToolCalls.has(evt.toolCallId) ? evt.toolCallId : void 0;
+		if (!resolvedId) resolvedId = this.findOpenToolCallByName(run, evt.toolName);
+		if (!resolvedId) return;
+		const span = run.openToolCalls.get(resolvedId);
+		if (!span) return;
+		const toolCallId = resolvedId;
+		span.endMs = Date.now();
+		span.outcome = Boolean(evt.error) ? "error" : "ok";
+		span.errorMessage = evt.error;
+		Object.assign(span.attrs, {
+			"gen_ai.tool.call.result:gated": evt.result,
+			"openclaw.error.message:gated": evt.error,
+			"openclaw.duration_ms": evt.durationMs
+		});
+		run.openToolCalls.delete(toolCallId);
+		run.closed.push(span);
+		run.history.push({
+			role: "tool",
+			parts: [{
+				type: "tool_call_response",
+				id: toolCallId,
+				response: evt.result ?? evt.error ?? ""
+			}]
+		});
 	}
-	onLlmOutput(evt, _ctx) {
-		const run = this.runs.get(evt.runId);
-		if (!run) return void 0;
-		const openCall = this.currentOpenCall(run);
-		if (!openCall) return void 0;
-		openCall.endMs = Date.now();
-		openCall.assistantTexts = evt.assistantTexts;
-		openCall.lastAssistant = evt.lastAssistant;
-		openCall.usage = evt.usage;
-		openCall.responseModel = evt.model;
-		openCall.resolvedRef = evt.resolvedRef;
-		return openCall;
+	onBeforeCompaction(evt, ctx) {
+		const runId = ctx.runId;
+		if (!runId) return;
+		const run = this.runs.get(runId);
+		if (!run) return;
+		run.openCompaction = {
+			spanId: hashHex(`${run.agent.traceId}:compaction:${run.closed.length}`, 16),
+			traceId: run.agent.traceId,
+			parentSpanId: run.agent.spanId,
+			name: "compaction",
+			startMs: Date.now(),
+			endMs: void 0,
+			attrs: {
+				...latitudeAttrs(ctx),
+				"openclaw.run.id": runId,
+				"openclaw.compaction.message_count.before": evt.messageCount,
+				"openclaw.compaction.session_file": evt.sessionFile,
+				"before_compaction.messages:gated": evt.messages ? normalizeMessages(evt.messages) : void 0
+			}
+		};
 	}
+	onAfterCompaction(evt, ctx) {
+		const runId = ctx.runId;
+		if (!runId) return;
+		const run = this.runs.get(runId);
+		if (!run?.openCompaction) return;
+		const span = run.openCompaction;
+		span.endMs = Date.now();
+		span.outcome = "ok";
+		Object.assign(span.attrs, {
+			"openclaw.compaction.message_count.after": evt.messageCount,
+			"openclaw.compaction.compacted_count": evt.compactedCount,
+			"openclaw.compaction.token_count": evt.tokenCount
+		});
+		run.openCompaction = void 0;
+		run.closed.push(span);
+	}
+	/**
+	* Open a `subagent` span on the parent run AND register the cross-run link
+	* so the child's `before_agent_start` can find us.
+	*/
+	onSubagentSpawned(evt, ctx) {
+		const parentRunId = ctx.runId;
+		if (!parentRunId) return;
+		const parent = this.runs.get(parentRunId);
+		if (!parent) return;
+		const span = {
+			spanId: hashHex(`${parent.agent.traceId}:subagent:${evt.runId}`, 16),
+			traceId: parent.agent.traceId,
+			parentSpanId: parent.agent.spanId,
+			name: "subagent",
+			startMs: Date.now(),
+			endMs: void 0,
+			attrs: {
+				...latitudeAttrs(ctx),
+				"openclaw.parent.run.id": parentRunId,
+				"openclaw.run.id": evt.runId,
+				"openclaw.subagent.child_session_key": evt.childSessionKey,
+				"openclaw.subagent.agent_id": evt.agentId,
+				"openclaw.subagent.label": evt.label,
+				"openclaw.subagent.mode": evt.mode,
+				"openclaw.subagent.thread_requested": evt.threadRequested,
+				"openclaw.subagent.requester.channel": evt.requester?.channel,
+				"openclaw.subagent.requester.account_id": evt.requester?.accountId,
+				"openclaw.subagent.requester.to": evt.requester?.to,
+				"openclaw.subagent.requester.thread_id": typeof evt.requester?.threadId === "string" || typeof evt.requester?.threadId === "number" ? String(evt.requester.threadId) : void 0
+			}
+		};
+		parent.childSubagentSpans.set(evt.runId, span);
+		this.evictStaleSubagentLinks();
+		this.subagentLinks.set(evt.runId, {
+			traceId: parent.agent.traceId,
+			subagentSpanId: span.spanId,
+			createdAt: Date.now()
+		});
+	}
+	onSubagentEnded(evt, ctx) {
+		const parentRunId = ctx.runId;
+		if (!parentRunId) return;
+		const parent = this.runs.get(parentRunId);
+		if (!parent) return;
+		const childRunId = evt.runId;
+		if (!childRunId) return;
+		const span = parent.childSubagentSpans.get(childRunId);
+		if (!span) return;
+		span.endMs = Date.now();
+		span.outcome = evt.outcome === "error" || Boolean(evt.error) ? "error" : "ok";
+		span.errorMessage = evt.error;
+		Object.assign(span.attrs, {
+			"openclaw.subagent.target_session_key": evt.targetSessionKey,
+			"openclaw.subagent.target_kind": evt.targetKind,
+			"openclaw.subagent.reason": evt.reason,
+			"openclaw.subagent.outcome": evt.outcome,
+			"openclaw.subagent.send_farewell": evt.sendFarewell,
+			"openclaw.subagent.account_id": evt.accountId
+		});
+		parent.childSubagentSpans.delete(childRunId);
+		parent.closed.push(span);
+	}
+	/**
+	* Close out the run: finish the agent span, abandon any still-open
+	* model_calls / tool_calls / compactions, and return everything ready to
+	* emit. Removes the subagent link if this was a child run.
+	*/
 	onAgentEnd(evt, ctx) {
 		const runId = ctx.runId;
 		if (!runId) return void 0;
 		const run = this.runs.get(runId);
-		if (!run) return void 0;
-		run.endMs = Date.now();
-		run.success = evt.success;
-		run.error = evt.error;
-		for (const call of run.llmCalls) {
-			if (call.endMs === void 0) {
-				call.endMs = run.endMs;
-				if (evt.error && call.error === void 0) call.error = evt.error;
-			}
-			for (const tool of call.toolCalls) if (tool.endMs === void 0) tool.endMs = run.endMs;
+		if (!run) {
+			this.subagentLinks.delete(runId);
+			return;
+		}
+		const now = Date.now();
+		run.agent.endMs = now;
+		run.agent.outcome = evt.success ? "ok" : "error";
+		run.agent.errorMessage = evt.error;
+		Object.assign(run.agent.attrs, {
+			"openclaw.duration_ms": evt.durationMs,
+			"openclaw.run.success": evt.success,
+			"openclaw.error.message:gated": evt.error,
+			"agent_end.messages:gated": normalizeMessages(evt.messages)
+		});
+		for (const span of run.openModelCalls.values()) {
+			span.endMs = now;
+			span.outcome = "error";
+			span.attrs["openclaw.outcome"] = "abandoned";
+			run.closed.push(span);
+		}
+		for (const span of run.openToolCalls.values()) {
+			span.endMs = now;
+			span.outcome = "error";
+			span.attrs["openclaw.outcome"] = "abandoned";
+			run.closed.push(span);
 		}
-		for (const tool of run.orphanTools) if (tool.endMs === void 0) tool.endMs = run.endMs;
+		if (run.openCompaction) {
+			run.openCompaction.endMs = now;
+			run.openCompaction.outcome = "error";
+			run.openCompaction.attrs["openclaw.outcome"] = "abandoned";
+			run.closed.push(run.openCompaction);
+		}
+		for (const span of run.childSubagentSpans.values()) {
+			span.endMs = now;
+			span.outcome = "error";
+			span.attrs["openclaw.subagent.outcome"] = "abandoned";
+			run.closed.push(span);
+		}
+		const spans = [run.agent, ...run.closed];
 		this.runs.delete(runId);
-		return run;
+		this.subagentLinks.delete(runId);
+		return {
+			runId,
+			spans
+		};
 	}
 	/** Drop a run without emitting — used on errors from the emit path. */
 	abandon(runId) {
 		this.runs.delete(runId);
+		this.subagentLinks.delete(runId);
 	}
-	/** Active runs count, for debug logging. */
-	inflightCount() {
-		return this.runs.size;
+	/** Test-only: how many cross-run subagent links we're holding. */
+	subagentLinkCount() {
+		return this.subagentLinks.size;
 	}
-	ensureRun(runId, ctx) {
-		let run = this.runs.get(runId);
-		if (run) return run;
-		run = {
-			runId,
-			sessionId: ctx.sessionId,
-			sessionKey: ctx.sessionKey,
-			agentId: ctx.agentId,
-			workspaceDir: ctx.workspaceDir,
-			messageProvider: ctx.messageProvider,
-			trigger: ctx.trigger,
-			channelId: ctx.channelId,
-			modelProviderId: ctx.modelProviderId,
-			modelId: ctx.modelId,
-			startMs: Date.now(),
-			endMs: void 0,
-			success: void 0,
-			error: void 0,
-			llmCalls: [],
-			orphanTools: []
-		};
-		this.runs.set(runId, run);
-		return run;
-	}
-	currentOpenCall(run) {
-		for (let i = run.llmCalls.length - 1; i >= 0; i--) {
-			const call = run.llmCalls[i];
-			if (call && call.endMs === void 0) return call;
+	/**
+	* Drop any subagent links whose child run never reached `agent_end`. Called
+	* before every `subagent_spawned` insert so the map stays bounded even when
+	* children crash mid-spawn or the plugin reloads.
+	*
+	* Two passes: TTL eviction (anything older than `SUBAGENT_LINK_TTL_MS`),
+	* then a hard size cap (when we're past `SUBAGENT_LINK_MAX`, drop the
+	* oldest until we're under).
+	*/
+	evictStaleSubagentLinks() {
+		const now = Date.now();
+		for (const [runId, link] of this.subagentLinks) if (now - link.createdAt > SUBAGENT_LINK_TTL_MS) this.subagentLinks.delete(runId);
+		if (this.subagentLinks.size <= SUBAGENT_LINK_MAX) return;
+		const sorted = Array.from(this.subagentLinks.entries()).sort((a, b) => a[1].createdAt - b[1].createdAt);
+		const toRemove = this.subagentLinks.size - SUBAGENT_LINK_MAX;
+		for (let i = 0; i < toRemove; i++) {
+			const entry = sorted[i];
+			if (entry) this.subagentLinks.delete(entry[0]);
 		}
 	}
-	findToolRecord(run, toolCallId, toolName) {
-		const matchesId = (t) => Boolean(toolCallId && t.toolCallId === toolCallId);
-		for (const call of run.llmCalls) for (const t of call.toolCalls) if (matchesId(t)) return t;
-		for (const t of run.orphanTools) if (matchesId(t)) return t;
-		for (let i = run.llmCalls.length - 1; i >= 0; i--) {
-			const call = run.llmCalls[i];
-			if (!call) continue;
-			for (let j = call.toolCalls.length - 1; j >= 0; j--) {
-				const t = call.toolCalls[j];
-				if (t && t.toolName === toolName && t.endMs === void 0) return t;
-			}
-		}
-		for (let i = run.orphanTools.length - 1; i >= 0; i--) {
-			const t = run.orphanTools[i];
-			if (t && t.toolName === toolName && t.endMs === void 0) return t;
+	findOpenToolCallByName(run, toolName) {
+		const target = `tool_call:${toolName}`;
+		const entries = Array.from(run.openToolCalls.entries());
+		for (let i = entries.length - 1; i >= 0; i--) {
+			const entry = entries[i];
+			if (!entry) continue;
+			const [id, span] = entry;
+			if (span.name === target) return id;
 		}
 	}
 };
+function flattenCtx(ctx) {
+	return {
+		"openclaw.run.id": ctx.runId,
+		"openclaw.session.id": ctx.sessionId,
+		"openclaw.session.key": ctx.sessionKey,
+		"openclaw.agent.id": ctx.agentId,
+		"openclaw.agent.name": ctx.agentId,
+		"openclaw.workspace.dir": ctx.workspaceDir,
+		"openclaw.message.provider": ctx.messageProvider,
+		"openclaw.trigger": ctx.trigger,
+		"openclaw.channel.id": ctx.channelId,
+		"openclaw.cron.job.id": ctx.jobId,
+		"openclaw.model.provider.id": ctx.modelProviderId,
+		"openclaw.model.id": ctx.modelId
+	};
+}
+/**
+* Build `latitude.tags` and `latitude.metadata` attrs from the hook context.
+* The OTLP encoder JSON-stringifies arrays/objects, which is the encoding
+* Latitude's resolver expects:
+*
+*   - `latitude.tags` is a JSON-encoded string array (`fromJsonStringArray`
+*     in domain/spans/src/otlp/resolvers/enrichment.ts).
+*   - `latitude.metadata` is a JSON-encoded string object (`fromJsonString`).
+*
+* Tags = the agent id, the channel id, and the trigger. When trigger is
+* `cron`, the tag becomes `cron:<jobId>` so dashboards can pivot on the
+* specific cron job. Each tag is conditionally included so absent ctx
+* fields don't produce empty entries.
+*
+* Metadata = every ctx field that's set, namespaced under `openclaw.*` so
+* it can't collide with metadata keys other plugins might emit.
+*/
+function latitudeAttrs(ctx) {
+	const tags = [];
+	if (ctx.agentId) tags.push(ctx.agentId);
+	if (ctx.channelId) tags.push(ctx.channelId);
+	if (ctx.trigger) tags.push(ctx.trigger === "cron" && ctx.jobId ? `cron:${ctx.jobId}` : ctx.trigger);
+	const metadata = {};
+	if (ctx.runId) metadata["openclaw.run.id"] = ctx.runId;
+	if (ctx.sessionId) metadata["openclaw.session.id"] = ctx.sessionId;
+	if (ctx.sessionKey) metadata["openclaw.session.key"] = ctx.sessionKey;
+	if (ctx.agentId) metadata["openclaw.agent.id"] = ctx.agentId;
+	if (ctx.workspaceDir) metadata["openclaw.workspace.dir"] = ctx.workspaceDir;
+	if (ctx.channelId) metadata["openclaw.channel.id"] = ctx.channelId;
+	if (ctx.messageProvider) metadata["openclaw.message.provider"] = ctx.messageProvider;
+	if (ctx.trigger) metadata["openclaw.trigger"] = ctx.trigger;
+	if (ctx.jobId) metadata["openclaw.cron.job.id"] = ctx.jobId;
+	if (ctx.modelProviderId) metadata["openclaw.model.provider.id"] = ctx.modelProviderId;
+	if (ctx.modelId) metadata["openclaw.model.id"] = ctx.modelId;
+	return {
+		"latitude.tags": tags.length > 0 ? tags : void 0,
+		"latitude.metadata": Object.keys(metadata).length > 0 ? metadata : void 0
+	};
+}
+function usageAttrs(usage) {
+	if (!usage) return {};
+	return {
+		"gen_ai.usage.input_tokens": usage.input,
+		"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,
+		"gen_ai.usage.total_tokens": usage.total
+	};
+}
+function hashHex(input, length) {
+	return createHash("sha256").update(input).digest("hex").slice(0, length);
+}
 //#endregion
 //#region src/plugin.ts
 /**
 * Register the Latitude plugin against an OpenClaw plugin API. OpenClaw calls
-* this once at plugin activation; we wire up `llm_input`, `llm_output`, tool
-* and lifecycle hooks to stream traces to Latitude.
+* this once at plugin activation; we wire up the granular paired hooks
+* (model_call_started/_ended, before_/after_tool_call, before_/after_compaction,
+* subagent_spawned/_ended, before_agent_start/agent_end) plus the
+* data-only feeds (llm_input/llm_output) that enrich the agent span.
 *
-* Every handler is fire-and-forget on OpenClaw's side (see
-* `src/plugins/hooks.ts` — runLlmInput/runLlmOutput are documented as
-* parallel and wrapped with `.catch()` at the call site in attempt.ts), so
-* nothing we do here can slow the agent loop.
+* Every typed hook on OpenClaw's side fires fire-and-forget for non-modifying
+* hooks; before_tool_call is a `runModifyingHook` where returning anything
+* other than undefined blocks the tool call. Our handler returns nothing —
+* keep it that way.
 */
 function registerLatitudePlugin(api, opts = {}) {
 	const config = opts.config ?? loadConfig(api.pluginConfig);
@@ -612,58 +893,65 @@ function registerLatitudePlugin(api, opts = {}) {
 		return;
 	}
 	logger.debug(`enabled: project=${config.project} base=${config.baseUrl} allowConversationAccess=${config.allowConversationAccess}`);
-	const builder = new TurnBuilder();
-	api.on("session_start", (evt, ctx) => {
-		builder.onSessionStart(evt, ctx);
-	});
-	api.on("llm_input", (evt, ctx) => {
-		try {
-			builder.onLlmInput(evt, ctx);
-		} catch (err) {
-			logger.warn(`llm_input handler failed: ${String(err)}`);
-		}
-	});
-	api.on("before_tool_call", (evt, ctx) => {
-		try {
-			builder.onBeforeToolCall(evt, ctx);
-		} catch (err) {
-			logger.warn(`before_tool_call handler failed: ${String(err)}`);
-		}
-	});
-	api.on("after_tool_call", (evt, ctx) => {
-		try {
-			builder.onAfterToolCall(evt, ctx);
-		} catch (err) {
-			logger.warn(`after_tool_call handler failed: ${String(err)}`);
-		}
-	});
-	api.on("llm_output", (evt, ctx) => {
-		try {
-			builder.onLlmOutput(evt, ctx);
-		} catch (err) {
-			logger.warn(`llm_output handler failed: ${String(err)}`);
-		}
-	});
-	api.on("agent_end", (evt, ctx) => {
-		try {
-			const run = builder.onAgentEnd(evt, ctx);
-			if (!run) {
-				logger.debug("agent_end fired without a matching run in flight");
-				return;
+	const builder = new SpanBuilder();
+	const wrap = (name, fn) => {
+		return (evt, ctx) => {
+			try {
+				fn(evt, ctx);
+			} catch (err) {
+				logger.warn(`${name} handler failed: ${String(err)}`);
 			}
-			opts.onEmit?.(run);
-			const payload = buildOtlpRequest(run, { allowConversationAccess: config.allowConversationAccess });
-			postTraces({
-				baseUrl: config.baseUrl,
-				apiKey: config.apiKey,
-				project: config.project,
-				payload,
-				logger
-			});
-		} catch (err) {
-			logger.warn(`agent_end handler failed: ${String(err)}`);
+		};
+	};
+	api.on("before_agent_start", wrap("before_agent_start", (evt, ctx) => {
+		builder.onBeforeAgentStart(evt, ctx);
+	}));
+	api.on("model_call_started", wrap("model_call_started", (evt, ctx) => {
+		builder.onModelCallStarted(evt, ctx);
+	}));
+	api.on("model_call_ended", wrap("model_call_ended", (evt, ctx) => {
+		builder.onModelCallEnded(evt, ctx);
+	}));
+	api.on("before_tool_call", wrap("before_tool_call", (evt, ctx) => {
+		builder.onBeforeToolCall(evt, ctx);
+	}));
+	api.on("after_tool_call", wrap("after_tool_call", (evt, ctx) => {
+		builder.onAfterToolCall(evt, ctx);
+	}));
+	api.on("before_compaction", wrap("before_compaction", (evt, ctx) => {
+		builder.onBeforeCompaction(evt, ctx);
+	}));
+	api.on("after_compaction", wrap("after_compaction", (evt, ctx) => {
+		builder.onAfterCompaction(evt, ctx);
+	}));
+	api.on("subagent_spawned", wrap("subagent_spawned", (evt, ctx) => {
+		builder.onSubagentSpawned(evt, ctx);
+	}));
+	api.on("subagent_ended", wrap("subagent_ended", (evt, ctx) => {
+		builder.onSubagentEnded(evt, ctx);
+	}));
+	api.on("llm_input", wrap("llm_input", (evt, ctx) => {
+		builder.onLlmInput(evt, ctx);
+	}));
+	api.on("llm_output", wrap("llm_output", (evt, ctx) => {
+		builder.onLlmOutput(evt, ctx);
+	}));
+	api.on("agent_end", wrap("agent_end", (evt, ctx) => {
+		const result = builder.onAgentEnd(evt, ctx);
+		if (!result) {
+			logger.debug("agent_end fired without a matching run in flight");
+			return;
 		}
-	});
+		opts.onEmit?.(result);
+		const payload = buildOtlpRequest(result, { allowConversationAccess: config.allowConversationAccess });
+		postTraces({
+			baseUrl: config.baseUrl,
+			apiKey: config.apiKey,
+			project: config.project,
+			payload,
+			logger
+		});
+	}));
 }
 //#endregion
 export { registerLatitudePlugin as default };