@latitude-data/openclaw-telemetry 0.0.1

package/dist/plugin.js

@@ -0,0 +1,646 @@
+import { createHash, randomUUID } from "node:crypto";
+import { arch, hostname, platform, release } from "node:os";
+//#region src/client.ts
+async function postTraces({ baseUrl, apiKey, project, payload, logger, timeoutMs = 1e4 }) {
+	const url = `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
+	const bodyText = JSON.stringify(payload);
+	logger.debug(`POST ${url} (project=${project}, ${bodyText.length} bytes)`);
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`,
+				"X-Latitude-Project": project
+			},
+			body: bodyText,
+			signal: controller.signal
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			logger.warn(`ingest HTTP ${res.status}: ${text.slice(0, 500)}`);
+		} else logger.debug(`ingest HTTP ${res.status}`);
+	} catch (err) {
+		logger.warn(`ingest failed: ${String(err)}`);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/config.ts
+function loadConfig(env = process.env) {
+	const apiKey = env.LATITUDE_API_KEY ?? "";
+	const baseUrl = env.LATITUDE_BASE_URL ?? "https://ingest.latitude.so";
+	const project = env.LATITUDE_PROJECT ?? "";
+	return {
+		apiKey,
+		baseUrl,
+		project,
+		enabled: (env.LATITUDE_OPENCLAW_ENABLED ?? "1") !== "0" && apiKey !== "" && project !== "",
+		debug: env.LATITUDE_DEBUG === "1"
+	};
+}
+//#endregion
+//#region src/logger.ts
+const PREFIX = "[latitude-openclaw]";
+function createLogger(debugEnabled) {
+	return {
+		debug: debugEnabled ? (msg) => process.stderr.write(`${PREFIX} ${msg}\n`) : () => {},
+		warn: (msg) => process.stderr.write(`${PREFIX} ${msg}\n`)
+	};
+}
+//#endregion
+//#region src/otlp.ts
+const SCOPE_NAME = "@latitude-data/openclaw-telemetry";
+const SCOPE_VERSION = "0.0.1";
+/** Build an OTLP export request for a single completed agent run. */
+function buildOtlpRequest(run) {
+	const spans = buildRunSpans(run);
+	return { resourceSpans: [{
+		resource: { attributes: resourceAttrs() },
+		scopeSpans: [{
+			scope: {
+				name: SCOPE_NAME,
+				version: SCOPE_VERSION
+			},
+			spans
+		}]
+	}] };
+}
+function buildRunSpans(run) {
+	const traceId = hashHex(`${run.sessionId ?? "session"}:${run.runId}`, 32);
+	const interactionSpanId = hashHex(`${traceId}:run`, 16);
+	const out = [buildInteractionSpan(traceId, interactionSpanId, run)];
+	run.llmCalls.forEach((call, idx) => {
+		const callSpanId = hashHex(`${traceId}:call:${idx}`, 16);
+		out.push(buildLlmSpan(traceId, interactionSpanId, callSpanId, call, idx, run));
+		call.toolCalls.forEach((tool, tIdx) => {
+			const toolSpanId = hashHex(`${traceId}:call:${idx}:tool:${tIdx}`, 16);
+			out.push(buildToolSpan(traceId, interactionSpanId, toolSpanId, tool, run));
+		});
+	});
+	run.orphanTools.forEach((tool, idx) => {
+		const toolSpanId = hashHex(`${traceId}:orphan-tool:${idx}`, 16);
+		out.push(buildToolSpan(traceId, interactionSpanId, toolSpanId, tool, run));
+	});
+	return out;
+}
+function buildInteractionSpan(traceId, spanId, run) {
+	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);
+	return {
+		traceId,
+		spanId,
+		parentSpanId: "",
+		name: "interaction",
+		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,
+			run.llmCalls[0]?.prompt ? str("user_prompt", run.llmCalls[0].prompt) : void 0
+		]),
+		status: { code: run.success === false ? 2 : 1 }
+	};
+}
+function buildLlmSpan(traceId, parentSpanId, spanId, call, callIdx, run) {
+	const startNs = msToNs(call.startMs);
+	const endNs = msToNs(call.endMs ?? call.startMs);
+	const inputMessages = buildInputMessages(call);
+	const outputMessages = buildOutputMessages(call);
+	const systemInstructions = call.systemPrompt ? JSON.stringify([{
+		type: "text",
+		content: call.systemPrompt
+	}]) : void 0;
+	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,
+			str("gen_ai.input.messages", JSON.stringify(inputMessages)),
+			str("gen_ai.output.messages", JSON.stringify(outputMessages)),
+			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 }
+	};
+}
+function buildToolSpan(traceId, parentSpanId, spanId, tool, run) {
+	const startNs = msToNs(tool.startMs);
+	const endNs = msToNs(tool.endMs ?? tool.startMs);
+	const isError = Boolean(tool.error);
+	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),
+			str("gen_ai.tool.call.arguments", safeJson(tool.params)),
+			tool.result !== void 0 ? str("gen_ai.tool.call.result", safeJson(tool.result)) : void 0,
+			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 }
+	};
+}
+function buildInputMessages(call) {
+	const out = [];
+	for (const msg of call.historyMessages) {
+		const normalized = normalizeHistoryMessage(msg);
+		if (normalized) out.push(normalized);
+	}
+	if (call.prompt.length > 0) out.push({
+		role: "user",
+		parts: [{
+			type: "text",
+			content: call.prompt
+		}]
+	});
+	return out;
+}
+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) {
+	if (!raw || typeof raw !== "object") return void 0;
+	const obj = raw;
+	const role = normalizeRole(obj.role);
+	const content = obj.content ?? obj.text ?? obj.message;
+	if (typeof content === "string") return {
+		role,
+		parts: [{
+			type: "text",
+			content
+		}]
+	};
+	if (Array.isArray(content)) {
+		const parts = [];
+		for (const block of content) {
+			const part = normalizeContentBlock(block);
+			if (part) parts.push(part);
+		}
+		return {
+			role,
+			parts: parts.length > 0 ? parts : [{
+				type: "text",
+				content: JSON.stringify(content)
+			}]
+		};
+	}
+	return {
+		role,
+		parts: [{
+			type: "text",
+			content: safeJson(raw)
+		}]
+	};
+}
+function normalizeContentBlock(raw) {
+	if (typeof raw === "string") return {
+		type: "text",
+		content: raw
+	};
+	if (!raw || typeof raw !== "object") return void 0;
+	const obj = raw;
+	const type = typeof obj.type === "string" ? obj.type : "text";
+	if (type === "text" && typeof obj.text === "string") return {
+		type: "text",
+		content: obj.text
+	};
+	if (type === "tool_use") return {
+		type: "tool_call",
+		id: typeof obj.id === "string" ? obj.id : "",
+		name: typeof obj.name === "string" ? obj.name : "",
+		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)
+	};
+	return {
+		type,
+		content: safeJson(raw)
+	};
+}
+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
+	};
+	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);
+	}
+	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 }
+	};
+}
+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);
+}
+function safeJson(value) {
+	try {
+		if (typeof value === "string") return value;
+		return JSON.stringify(value);
+	} catch {
+		return "";
+	}
+}
+//#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 {
+	runs = /* @__PURE__ */ new Map();
+	onSessionStart(_evt, _ctx) {}
+	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,
+			startMs: Date.now(),
+			endMs: void 0,
+			error: void 0,
+			toolCalls: []
+		};
+		run.llmCalls.push(call);
+		return call;
+	}
+	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,
+			startMs: Date.now(),
+			endMs: void 0,
+			durationMs: void 0,
+			agentId: ctx.agentId
+		};
+		const openCall = this.currentOpenCall(run);
+		if (openCall) openCall.toolCalls.push(tool);
+		else run.orphanTools.push(tool);
+	}
+	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();
+	}
+	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;
+	}
+	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;
+		}
+		for (const tool of run.orphanTools) if (tool.endMs === void 0) tool.endMs = run.endMs;
+		this.runs.delete(runId);
+		return run;
+	}
+	/** Drop a run without emitting — used on errors from the emit path. */
+	abandon(runId) {
+		this.runs.delete(runId);
+	}
+	/** Active runs count, for debug logging. */
+	inflightCount() {
+		return this.runs.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;
+		}
+	}
+	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;
+		}
+	}
+};
+//#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.
+*
+* 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.
+*/
+function registerLatitudePlugin(api, opts = {}) {
+	const config = opts.config ?? loadConfig();
+	const logger = opts.logger ?? createLogger(config.debug);
+	if (!config.enabled) {
+		if (config.apiKey === "") logger.debug("disabled: LATITUDE_API_KEY is empty");
+		if (config.project === "") logger.debug("disabled: LATITUDE_PROJECT is empty");
+		return;
+	}
+	logger.debug(`enabled: project=${config.project} base=${config.baseUrl}`);
+	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;
+			}
+			opts.onEmit?.(run);
+			const payload = buildOtlpRequest(run);
+			postTraces({
+				baseUrl: config.baseUrl,
+				apiKey: config.apiKey,
+				project: config.project,
+				payload,
+				logger
+			});
+		} catch (err) {
+			logger.warn(`agent_end handler failed: ${String(err)}`);
+		}
+	});
+}
+//#endregion
+export { registerLatitudePlugin as default };
+
+//# sourceMappingURL=plugin.js.map