@lmnr-ai/lmnr 0.8.50 → 0.8.51

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-Ctb5zv51.cjs");
-const require_utils = require("./utils-CNR1tzh5.cjs");
+const require_utils = require("./utils-Cq24YsD_.cjs");
 const require_consts = require("./consts-9rSS0oeR.cjs");
 let path = require("path");
 path = require_rolldown_runtime.__toESM(path);
@@ -183,7 +183,7 @@ var LaminarDataset = class extends EvaluationDataset {
 	*/
 	async push(paths, recursive = false) {
 		if (!this.client) throw new Error("Client not set");
-		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-RXJzJyiI.cjs")).then((n) => n.file_utils_exports);
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-Cyx-2kqE.cjs")).then((n) => n.file_utils_exports);
 		const data = await loadFromPaths(Array.isArray(paths) ? paths : [paths], recursive);
 		if (data.length === 0) {
 			console.warn("No data to push. Skipping");
@@ -8334,165 +8334,10 @@ async function evaluate({ data, executor, evaluators, groupName, name, metadata,
 //#region src/integrations/eve.ts
 const logger$2 = require_utils.initializeLogger();
 const EVE_REPORTER_TRACER_NAME = "@lmnr-ai/lmnr/eve-reporter";
-const EVE_CLIENT_MODULE = "eve/client";
-const TRACEPARENT_HEADER$1 = "traceparent";
-/** Same wire name the Temporal instrumentation uses (`temporal/consts.ts`). */
-const LAMINAR_SPAN_CONTEXT_HEADER$1 = "x-lmnr-span-context";
-/**
-* Root span name for every propagated eval, and it never changes. eve calls
-* `ClientSession.send` before any hook that knows which eval is in flight, and
-* eve exposes no `onEvalStart`, so the id simply is not knowable here. Renaming
-* the span later would invalidate the `lmnr.span.path` the processor already
-* stamped on it and on every descendant, and would make the path we propagate
-* to the agent stale. The eval id rides on `lmnr.eve.eval.id`, on the trace
-* metadata, and on the datapoint instead.
-*/
-const ROOT_SPAN_NAME = "eve eval";
-const EXECUTOR_SPAN_NAME = "executor";
-/** Prototypes already patched — `send` must never be wrapped twice. */
-const patchedSendPrototypes = /* @__PURE__ */ new WeakSet();
-/**
-* Per-eve-client-session state. Keyed off the `ClientSession` instance rather
-* than an AsyncLocalStorage frame or a "current eval" global: eve runs up to
-* `maxConcurrency` evals at once, and each eval builds its own `ClientSession`
-* (`EvalSessionManager` calls `client.session()` per `EvalSessionDriver`), so
-* the instance is the only correct correlation key available inside `send`.
-*/
-const traceByClientSession = /* @__PURE__ */ new WeakMap();
-/** eve session id -> trace, read by `onEvalComplete` via `result.sessionId`. */
-const traceByEveSessionId = /* @__PURE__ */ new Map();
-/** Set by the running reporter's `onRunStart`; cleared by `onRunComplete`. */
-let activeSessionTraceFactory = null;
-/** Mirrors eve's own `normalizeSendTurnInput`, then merges the trace headers. */
-const withTraceHeaders = (input, headers) => {
-	const payload = typeof input === "string" ? { message: input } : { ...input };
-	payload.headers = {
-		...payload.headers ?? {},
-		...headers
-	};
-	return payload;
-};
-const openSessionTrace = (clientSession) => {
-	try {
-		const existing = traceByClientSession.get(clientSession);
-		if (existing) return existing;
-		const minted = activeSessionTraceFactory?.();
-		if (minted) traceByClientSession.set(clientSession, minted);
-		return minted;
-	} catch (error) {
-		logger$2.warn(`Laminar eve reporter: failed to open a session trace: ` + require_utils.errorMessage(error));
-		return;
-	}
-};
-/**
-* eve assigns the session id on the POST that `send` awaits, so the returned
-* `MessageResponse` is the earliest place the runner can bind the eve session
-* id to the trace it minted.
-*/
-const recordEveSessionId = (response, sessionTrace) => {
-	const sessionId = response?.sessionId;
-	if (typeof sessionId !== "string" || sessionId.length === 0) return;
-	sessionTrace.sessionIds.add(sessionId);
-	traceByEveSessionId.set(sessionId, sessionTrace);
-};
-/**
-* Build the propagation headers for the EXECUTOR span. Plain HTTP strings — eve
-* forwards `SendTurnPayload.headers` verbatim to `fetch`.
-*
-* The Laminar context carries the full path. Laminar nests spans by
-* `lmnr.span.ids_path`, not by OTel `parentSpanId`, so a receiver that adopts
-* only the ids lands its spans as a second root on our trace. The path is what
-* makes the agent's subtree render UNDER the executor. Both paths are constants
-* here — neither the root nor the executor span is ever renamed.
-*/
-const buildTraceHeaders = (rootSpan, executorSpan) => {
-	const spanContext = executorSpan.spanContext();
-	const laminarContext = {
-		traceId: require_utils.otelTraceIdToUUID(spanContext.traceId),
-		spanId: require_utils.otelSpanIdToUUID(spanContext.spanId),
-		isRemote: true,
-		spanPath: [ROOT_SPAN_NAME, EXECUTOR_SPAN_NAME],
-		spanIdsPath: [require_utils.otelSpanIdToUUID(rootSpan.spanContext().spanId), require_utils.otelSpanIdToUUID(spanContext.spanId)]
-	};
-	return {
-		[TRACEPARENT_HEADER$1]: `00-${spanContext.traceId}-${spanContext.spanId}-01`,
-		[LAMINAR_SPAN_CONTEXT_HEADER$1]: JSON.stringify(laminarContext)
-	};
-};
-/**
-* Bind this session's ROOT span into the calling eval's async context, so work
-* the eval does in the RUNNER process after `send` resolves lands on this trace
-* instead of opening its own. The concrete case is `t.judge.autoevals.*`: eve
-* runs the judge's model call in the runner, and Laminar's AI SDK integration
-* parents it to `LaminarContextManager.getContext()`.
-*
-* The root — not a pre-opened judge span — is the binding target on purpose.
-* An eval may record any number of judge assertions, and each one runs its own
-* model call. Binding the root gives every judge its own child of the root; a
-* single pre-opened parent would collect all of them under whichever judge
-* happened to run first.
-*
-* `pushContext` uses `AsyncLocalStorage.enterWith`, so this MUST run
-* synchronously before `send`'s first `await` — at that point we are still
-* executing in the caller's async context, so the store we set is the one
-* `test(t)` continues with. Each eval's `test(t)` runs in its own async chain,
-* so concurrent evals never see each other's root span; do NOT replace this
-* with the process-global context stack, which would cross-attribute.
-*
-* Judge spans reach Laminar only when the runner opts in — `Laminar.initialize()`
-* plus a globally registered AI SDK telemetry integration. Without that the
-* binding is inert, never wrong.
-*
-* Never popped: the store dies with the eval's async chain.
-*/
-const bindEvalContext = (sessionTrace) => {
-	try {
-		LaminarContextManager.pushContext(_opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, sessionTrace.rootSpan));
-	} catch (error) {
-		logger$2.warn(`Laminar eve reporter: failed to bind the eval context: ` + require_utils.errorMessage(error));
-	}
-};
-/**
-* Wrap `ClientSession.prototype.send` so every eve turn carries the trace
-* context of a runner-minted Laminar span. Idempotent per prototype.
-*
-* @internal Exported for tests, which drive it with a stub class so the suite
-* keeps no dependency on eve.
-*/
-const patchEveClientSession = (sessionClass) => {
-	const prototype = sessionClass?.prototype;
-	const original = prototype?.send;
-	if (!prototype || typeof original !== "function") return false;
-	if (patchedSendPrototypes.has(prototype)) return true;
-	prototype.send = async function(input) {
-		const sessionTrace = openSessionTrace(this);
-		if (!sessionTrace) return original.call(this, input);
-		bindEvalContext(sessionTrace);
-		const response = await original.call(this, withTraceHeaders(input, sessionTrace.headers));
-		try {
-			recordEveSessionId(response, sessionTrace);
-		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to record the eve session id: ` + require_utils.errorMessage(error));
-		}
-		return response;
-	};
-	patchedSendPrototypes.add(prototype);
-	return true;
-};
-/**
-* Load eve's `ClientSession` without depending on eve. Mirrors the guarded
-* dynamic import in eve's own Braintrust reporter (`loadBraintrustSdk`), except
-* a missing eve degrades instead of throwing — the reporter must keep working
-* when it is registered outside an eve run.
-*/
-const loadEveClientSession = async () => {
-	try {
-		const sessionClass = (await import(EVE_CLIENT_MODULE)).ClientSession;
-		return typeof sessionClass === "function" ? sessionClass : void 0;
-	} catch {
-		return;
-	}
-};
+const OTEL_TRACE_ID_RE = /^[0-9a-f]{32}$/iu;
+const OTEL_SPAN_ID_RE = /^[0-9a-f]{16}$/iu;
+const ZERO_TRACE_ID = "0".repeat(32);
+const ZERO_SPAN_ID = "0".repeat(16);
 const didAssertionPass = (assertion) => {
 	if (typeof assertion.passed === "boolean") return assertion.passed;
 	if (typeof assertion.score === "number") {
@@ -8501,14 +8346,8 @@ const didAssertionPass = (assertion) => {
 	}
 	return true;
 };
-/**
-* Keep Laminar's top-level score columns stable across heterogeneous eve evals.
-* Detailed assertion outcomes live in metadata; sparse per-assertion score keys
-* make Laminar's eval UI look incomplete when different eval files assert
-* different things.
-*/
-const resultToScores = (result) => {
-	const assertions = result.assertions ?? [];
+/** Keep Laminar's score columns stable across heterogeneous eve evals. */
+const resultToScores = (result, assertions) => {
 	const gateAssertions = assertions.filter((assertion) => assertion.severity === "gate");
 	const thresholdedSoftAssertions = assertions.filter((assertion) => assertion.severity === "soft" && typeof assertion.threshold === "number");
 	return {
@@ -8526,7 +8365,6 @@ const assertionsMetadata = (assertions) => assertions.map((assertion) => ({
 	message: assertion.message,
 	metadata: assertion.metadata
 }));
-/** Surface failed assertions in metadata so a failing run is debuggable. */
 const failedAssertionsMetadata = (assertions) => {
 	const failed = assertions.filter((assertion) => !didAssertionPass(assertion)).map((assertion) => ({
 		name: assertion.name,
@@ -8534,79 +8372,62 @@ const failedAssertionsMetadata = (assertions) => {
 	}));
 	return failed.length > 0 ? { failedAssertions: failed } : {};
 };
-const traceIdFromSpan = (span) => require_utils.otelTraceIdToUUID(span.spanContext().traceId);
+const validTraceContext = (context) => context != null && typeof context.traceId === "string" && OTEL_TRACE_ID_RE.test(context.traceId) && context.traceId !== ZERO_TRACE_ID && typeof context.spanId === "string" && OTEL_SPAN_ID_RE.test(context.spanId) && context.spanId !== ZERO_SPAN_ID && typeof context.traceFlags === "number" && Number.isInteger(context.traceFlags) && context.traceFlags >= 0 && context.traceFlags <= 255;
+const normalizeTraceContexts = (contexts) => Array.isArray(contexts) ? contexts.filter(validTraceContext) : [];
+const isSampledTraceContext = (context) => (context.traceFlags & 1) === 1;
+const selectTraceContext = (contexts) => contexts.find((context) => context.primary === true && isSampledTraceContext(context)) ?? contexts.find(isSampledTraceContext);
+const traceContextMetadata = (contexts) => contexts.map((context) => ({
+	traceId: context.traceId,
+	spanId: context.spanId,
+	traceFlags: context.traceFlags,
+	primary: context.primary,
+	sessionId: context.sessionId
+}));
 /**
-* A Laminar reporter for eve evals. Register it globally in `evals.config.ts`
-* or per-eval via the `reporters` field — eve runs and grades each eval, then
-* hands the graded result here, and this reporter ships it to Laminar as an
-* evaluation run with one datapoint per eval.
-*
-* The datapoint's trace id is never looked up — the reporter OWNS the trace.
-* `patchEveClientSession` wraps eve's `ClientSession.send` and mints the
-* EVALUATION root + EXECUTOR child on the first turn of each session, so the
-* runner already knows the trace id and pushes it to the agent as a
-* `traceparent` header. The eve session id is only the in-process key that ties
-* the send we instrumented to the graded result eve hands back later.
-*
-* Two outcomes, recorded on `metadata.traceResolution`:
-*
-* 1. `"propagated"` — the normal path, above. The agent joins the trace only
-*    when `agent/instrumentation.ts` sets `traceChannelRequests: true` and the
-*    agent process runs with `WORKFLOW_TRACE_MODE=continuous`.
-* 2. `"reporter-fallback"` — no session trace was minted (propagation disabled,
-*    or eve produced no session id). The reporter opens its own EVALUATION span
-*    so the grade still lands somewhere debuggable; it holds no agent work.
-*
-* `t.judge.autoevals.*` model calls run in the RUNNER process, and they reach
-* Laminar only when the runner registers an AI SDK telemetry integration. eve
-* imports `generateText` inside its own bundle, so `wrapAISDK` cannot reach it —
-* but AI SDK v7 reads registered integrations off `globalThis`, which does. One
-* line in `evals.config.ts`:
+* Reports eve eval results to Laminar.
 *
-* ```ts
-* registerTelemetry(new LaminarAiSdkTelemetry());
-* ```
+* Eve 0.35+ gives reporters every native trace context observed during an eval.
+* The reporter links the datapoint to the first sampled primary trace (or the
+* first sampled trace when there is no sampled primary), records every valid
+* context in metadata, and adds
+* a small EVALUATION span to the selected native trace for the grade. When eve
+* reports no usable context, a reporter-owned fallback trace preserves the
+* result without pretending it contains agent work.
 *
-* Judge spans and eve eval spans then share ONE tracer provider — whichever of
-* the two initialized Laminar first (see {@link LaminarReporter.ensureTracing}).
-* Each judge gets its own span under the eval's root — see
-* {@link bindEvalContext}, and {@link LaminarReporter.flush} for how spans ship.
-* Without that line the reporter still records every assertion's score as an
-* EVALUATOR span; only the model call is missing.
+* The agent must export its native OpenTelemetry spans to the same Laminar
+* project. In the eve agent, declare a destination like:
 *
-* @example
 * ```ts
-* import { defineEvalConfig } from "eve/evals";
-* import { LaminarReporter } from "@lmnr-ai/lmnr";
+* import { LaminarSpanProcessor } from "@lmnr-ai/lmnr";
+* import { otelIntegration } from "eve/instrumentation/otel";
 *
-* export default defineEvalConfig({
-*   reporters: [new LaminarReporter({ name: "weather-agent" })],
+* export default otelIntegration({
+*   spanProcessors: [new LaminarSpanProcessor()],
 * });
 * ```
 */
 var LaminarReporter = class {
 	constructor(options = {}) {
 		this.evalsById = /* @__PURE__ */ new Map();
-		this.index = 0;
-		this.openSessionTraces = /* @__PURE__ */ new Set();
-		this.sessionTraceFactory = () => this.mintSessionTrace();
+		this.evalIndexById = /* @__PURE__ */ new Map();
+		this.nextFallbackIndex = 0;
 		this.options = options;
 	}
 	async onRunStart(evaluations, target) {
 		this.evalId = void 0;
-		this.evalsById = new Map(evaluations.filter((evaluation) => typeof evaluation.id === "string").map((evaluation) => [evaluation.id, evaluation]));
-		this.index = 0;
-		this.finishOpenSessionTraces();
+		const identifiedEvaluations = evaluations.map((evaluation, index) => ({
+			evaluation,
+			index
+		})).filter((item) => typeof item.evaluation.id === "string");
+		this.evalsById = new Map(identifiedEvaluations.map(({ evaluation }) => [evaluation.id, evaluation]));
+		this.evalIndexById = new Map(identifiedEvaluations.map(({ evaluation, index }) => [evaluation.id, index]));
+		this.nextFallbackIndex = evaluations.length;
 		try {
 			this.client = this.options.client ?? new require_utils.LaminarClient({
 				baseUrl: this.options.baseUrl,
 				projectApiKey: this.options.projectApiKey
 			});
 			this.ensureTracing();
-			if (this.options.propagateTraceContext !== false) {
-				activeSessionTraceFactory = this.sessionTraceFactory;
-				patchEveClientSession(await loadEveClientSession());
-			}
 			const evaluation = await this.client.evals.init(this.options.name, this.options.groupName, {
 				...this.options.metadata ?? {},
 				source: "eve",
@@ -8619,26 +8440,25 @@ var LaminarReporter = class {
 			process.stdout.write(`\nLaminar: check eve eval results at ${url}\n`);
 		} catch (error) {
 			logger$2.error(`Laminar eve reporter: failed to start run: ${require_utils.errorMessage(error)}`);
-			if (!this.evalId) {
-				this.client = void 0;
-				if (activeSessionTraceFactory === this.sessionTraceFactory) activeSessionTraceFactory = null;
-			}
+			if (!this.evalId) this.client = void 0;
 		}
 	}
-	async onEvalComplete(result) {
+	async onEvalComplete(result, context) {
 		const client = this.client;
 		const evalId = this.evalId;
 		if (!client || !evalId) return;
-		const index = this.index++;
+		const index = typeof result.id === "string" ? this.evalIndexById.get(result.id) ?? this.nextFallbackIndex++ : this.nextFallbackIndex++;
 		const task = result.result ?? {};
 		const derived = task.derived ?? {};
-		const assertions = result.assertions ?? [];
-		const evalDescription = (typeof result.id === "string" ? this.evalsById.get(result.id) : void 0)?.description;
-		const traceResolution = this.resolveDatapointTrace({
-			evalId: result.id ?? String(index),
+		const assertions = Array.isArray(result.assertions) ? result.assertions.filter((assertion) => assertion != null && typeof assertion === "object") : [];
+		const evalDefinition = typeof result.id === "string" ? this.evalsById.get(result.id) : void 0;
+		const evalDescription = context?.evaluation?.description ?? evalDefinition?.description;
+		const contexts = normalizeTraceContexts(context?.traceContexts ?? task.traceContexts ?? []);
+		const gradeTrace = this.openGradeTrace({
+			contexts,
 			description: evalDescription,
-			verdict: result.verdict,
-			sessionId: task.sessionId
+			evalId: result.id ?? String(index),
+			verdict: result.verdict
 		});
 		try {
 			const datapointId = await client.evals.createDatapoint({
@@ -8646,17 +8466,19 @@ var LaminarReporter = class {
 				data: result.id ?? null,
 				target: task.finalMessage ?? null,
 				index,
-				traceId: traceResolution.traceId,
+				traceId: gradeTrace.traceId,
 				metadata: {
 					name: result.id,
 					verdict: result.verdict,
 					status: task.status,
 					description: evalDescription,
 					sessionId: task.sessionId,
-					traceResolution: traceResolution.source,
+					traceResolution: gradeTrace.source,
+					selectedTraceContext: gradeTrace.selected ? traceContextMetadata([gradeTrace.selected])[0] : void 0,
+					traceContexts: traceContextMetadata(gradeTrace.contexts),
 					skipReason: result.skipReason,
 					error: result.error,
-					toolCalls: (derived.toolCalls ?? []).map((call) => call.name).filter((name) => typeof name === "string"),
+					toolCalls: (Array.isArray(derived.toolCalls) ? derived.toolCalls : []).map((call) => call?.name).filter((name) => typeof name === "string"),
 					toolCallCount: derived.toolCallCount,
 					parked: derived.parked,
 					failureCode: derived.failureCode,
@@ -8665,44 +8487,30 @@ var LaminarReporter = class {
 					...failedAssertionsMetadata(assertions)
 				}
 			});
-			const executorOutput = task.output ?? task.finalMessage ?? null;
 			await client.evals.updateDatapoint({
 				evalId,
 				datapointId,
-				scores: resultToScores(result),
-				executorOutput
+				scores: resultToScores(result, assertions),
+				executorOutput: task.output ?? task.finalMessage ?? null
 			});
 		} catch (error) {
-			if (traceResolution.source === "reporter-fallback") traceResolution.span.recordException(error);
+			gradeTrace.span.recordException(error);
 			logger$2.error(`Laminar eve reporter: failed to report eval "${result.id ?? index}": ${require_utils.errorMessage(error)}`);
 		} finally {
-			if (traceResolution.source === "reporter-fallback") traceResolution.span.end();
-			if (traceResolution.source === "propagated") this.finishSessionTrace(traceResolution.sessionTrace, {
-				evalId: result.id,
-				description: evalDescription,
-				verdict: result.verdict,
-				status: task.status,
+			this.finishGradeTrace(gradeTrace, {
+				assertions,
 				output: task.output ?? task.finalMessage ?? null,
-				assertions
+				status: task.status
 			});
 			await this.flush();
 		}
 	}
-	async onRunComplete() {
-		this.finishOpenSessionTraces();
-		if (activeSessionTraceFactory === this.sessionTraceFactory) activeSessionTraceFactory = null;
+	async onRunComplete(_summary) {
 		await this.flush();
 		this.evalId = void 0;
 		this.evalsById.clear();
+		this.evalIndexById.clear();
 	}
-	/**
-	* Point the process's Laminar tracing at this reporter's project, unless
-	* something already initialized it. Mirrors `LaminarAiSdkTelemetry`, which
-	* initializes the same way for judge spans — so eve eval spans and judge
-	* spans share ONE tracer provider however the run was set up. Without this,
-	* `getTracer()` returns a noop whenever nobody registered the AI SDK
-	* integration, and every eve span would be dropped silently.
-	*/
 	ensureTracing() {
 		if (Laminar.initialized()) {
 			const ourKey = this.client?.apiKey ?? this.options.projectApiKey;
@@ -8718,140 +8526,79 @@ var LaminarReporter = class {
 			disableBatch: true
 		});
 	}
-	/**
-	* Flush the process's Laminar pipeline — eve eval spans AND judge spans, which
-	* now share one provider. eve ends `eve eval` with `process.exit()` (skipping
-	* `beforeExit`), so these calls are the only points at which spans ship.
-	* Never `shutdown()`: the pipeline may belong to the host, not to us.
-	*/
 	async flush() {
 		try {
 			await Laminar.flush();
 		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to flush spans: ` + require_utils.errorMessage(error));
+			logger$2.warn(`Laminar eve reporter: failed to flush spans: ${require_utils.errorMessage(error)}`);
 		}
 	}
-	/**
-	* Open the eval's Laminar spans for one eve client session: an EVALUATION
-	* root plus the EXECUTOR child the agent's turn is parented to. Called from
-	* the patched `send`, so it must never throw into the user's eval.
-	*/
-	mintSessionTrace() {
+	openGradeTrace({ contexts, description, evalId, verdict }) {
+		const selected = selectTraceContext(contexts);
 		const tracer = getTracer();
-		const rootSpan = tracer.startSpan(ROOT_SPAN_NAME, { attributes: {
-			[require_utils.SPAN_TYPE]: "EVALUATION",
-			[require_utils.TRACE_TYPE]: "EVALUATION",
-			"lmnr.eve.reporter": EVE_REPORTER_TRACER_NAME
-		} }, _opentelemetry_api.ROOT_CONTEXT);
-		const executorSpan = tracer.startSpan(EXECUTOR_SPAN_NAME, { attributes: {
-			[require_utils.SPAN_TYPE]: "EXECUTOR",
-			[require_utils.TRACE_TYPE]: "EVALUATION"
-		} }, _opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, rootSpan));
-		const sessionTrace = {
-			traceId: require_utils.otelTraceIdToUUID(rootSpan.spanContext().traceId),
-			rootSpan,
-			executorSpan,
-			tracer,
-			headers: buildTraceHeaders(rootSpan, executorSpan),
-			sessionIds: /* @__PURE__ */ new Set(),
-			ended: false
-		};
-		this.openSessionTraces.add(sessionTrace);
-		return sessionTrace;
-	}
-	/** Grade, close and release one session trace. Idempotent. */
-	finishSessionTrace(sessionTrace, grade) {
-		if (sessionTrace.ended) return;
-		sessionTrace.ended = true;
-		this.openSessionTraces.delete(sessionTrace);
-		for (const sessionId of sessionTrace.sessionIds) traceByEveSessionId.delete(sessionId);
-		try {
-			sessionTrace.rootSpan.setAttributes({
-				"lmnr.eve.eval.id": grade.evalId ?? "",
-				"lmnr.eve.eval.verdict": grade.verdict ?? "",
-				"lmnr.eve.eval.status": grade.status ?? "",
-				[require_utils.SPAN_INPUT]: JSON.stringify({
-					evalId: grade.evalId,
-					description: grade.description
-				}),
-				[require_utils.SPAN_OUTPUT]: JSON.stringify(grade.output ?? null),
-				...require_utils.metadataToAttributes({
-					source: "eve",
-					eveEvalId: grade.evalId ?? "",
-					eveEvalDescription: grade.description ?? "",
-					eveEvalVerdict: grade.verdict ?? "",
-					eveSessionId: [...sessionTrace.sessionIds].join(",")
-				})
-			});
-			sessionTrace.executorSpan.setAttribute(require_utils.SPAN_OUTPUT, JSON.stringify(grade.output ?? null));
-			this.recordEvaluatorSpans(sessionTrace, grade.assertions ?? []);
-			sessionTrace.executorSpan.end();
-			sessionTrace.rootSpan.end();
-		} catch (error) {
-			logger$2.warn(`Laminar eve reporter: failed to finish the session trace: ` + require_utils.errorMessage(error));
-		}
-	}
-	/**
-	* One EVALUATOR span per eve assertion, judge or not. They are created at
-	* grade time (the assertions only exist then) as short children of the
-	* still-open root. No explicit parent path is needed: the root keeps the name
-	* it was minted with, so the processor's cached path for it is still correct.
-	*/
-	recordEvaluatorSpans(sessionTrace, assertions) {
-		const rootContext = _opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, sessionTrace.rootSpan);
-		for (const assertion of assertions) {
-			const name = assertion.name ?? "assertion";
-			const output = JSON.stringify({
-				score: assertion.score ?? null,
-				passed: didAssertionPass(assertion),
-				severity: assertion.severity,
-				threshold: assertion.threshold,
-				message: assertion.message
-			});
-			sessionTrace.tracer.startSpan(name, { attributes: {
-				[require_utils.SPAN_TYPE]: "EVALUATOR",
-				[require_utils.TRACE_TYPE]: "EVALUATION",
-				[require_utils.SPAN_OUTPUT]: output
-			} }, rootContext).end();
-		}
-	}
-	finishOpenSessionTraces() {
-		for (const sessionTrace of [...this.openSessionTraces]) this.finishSessionTrace(sessionTrace, {});
-	}
-	/**
-	* Resolve the trace this datapoint links to. There is no lookup: either
-	* `patchEveClientSession` already minted the session's trace (and we know its
-	* id), or we open a reporter-owned EVALUATION span to hold the grade.
-	*/
-	resolveDatapointTrace({ evalId, description, verdict, sessionId }) {
-		const sessionTrace = sessionId ? traceByEveSessionId.get(sessionId) : void 0;
-		if (sessionTrace) return {
-			traceId: sessionTrace.traceId,
-			source: "propagated",
-			sessionTrace
-		};
-		const span = getTracer().startSpan(`eve eval ${evalId}`, { attributes: {
+		const parentContext = selected ? _opentelemetry_api.trace.setSpanContext(_opentelemetry_api.ROOT_CONTEXT, this.toSpanContext(selected)) : _opentelemetry_api.ROOT_CONTEXT;
+		const source = selected ? "eve-native" : "reporter-fallback";
+		const span = tracer.startSpan(`eve eval ${evalId}`, { attributes: {
 			[require_utils.SPAN_TYPE]: "EVALUATION",
 			[require_utils.TRACE_TYPE]: "EVALUATION",
 			"lmnr.eve.reporter": EVE_REPORTER_TRACER_NAME,
 			"lmnr.eve.eval.id": evalId,
 			"lmnr.eve.eval.verdict": verdict ?? "",
-			...sessionId ? { "lmnr.eve.session.id": sessionId } : {},
-			"lmnr.eve.trace_resolution": "reporter-fallback",
+			"lmnr.eve.trace_resolution": source,
 			...require_utils.metadataToAttributes({
 				source: "eve",
 				eveEvalId: evalId,
 				eveEvalDescription: description ?? "",
 				eveEvalVerdict: verdict ?? "",
-				eveSessionId: sessionId ?? ""
+				eveSessionId: selected?.sessionId ?? "",
+				eveTraceCount: contexts.length
+			}),
+			[require_utils.SPAN_INPUT]: JSON.stringify({
+				evalId,
+				description
 			})
-		} }, _opentelemetry_api.ROOT_CONTEXT);
+		} }, parentContext);
+		return {
+			traceId: require_utils.otelTraceIdToUUID(span.spanContext().traceId),
+			source,
+			span,
+			tracer,
+			selected,
+			contexts
+		};
+	}
+	toSpanContext(context) {
 		return {
-			traceId: traceIdFromSpan(span),
-			source: "reporter-fallback",
-			span
+			traceId: context.traceId.toLowerCase(),
+			spanId: context.spanId.toLowerCase(),
+			traceFlags: context.traceFlags,
+			isRemote: true
 		};
 	}
+	finishGradeTrace(gradeTrace, grade) {
+		try {
+			gradeTrace.span.setAttributes({
+				"lmnr.eve.eval.status": grade.status ?? "",
+				[require_utils.SPAN_OUTPUT]: JSON.stringify(grade.output ?? null)
+			});
+			const parentContext = _opentelemetry_api.trace.setSpan(_opentelemetry_api.ROOT_CONTEXT, gradeTrace.span);
+			for (const assertion of grade.assertions) gradeTrace.tracer.startSpan(assertion.name ?? "assertion", { attributes: {
+				[require_utils.SPAN_TYPE]: "EVALUATOR",
+				[require_utils.TRACE_TYPE]: "EVALUATION",
+				[require_utils.SPAN_OUTPUT]: JSON.stringify({
+					score: assertion.score ?? null,
+					passed: didAssertionPass(assertion),
+					severity: assertion.severity,
+					threshold: assertion.threshold,
+					message: assertion.message
+				})
+			} }, parentContext).end();
+		} catch (error) {
+			logger$2.warn(`Laminar eve reporter: failed to finish the grade trace: ${require_utils.errorMessage(error)}`);
+		} finally {
+			gradeTrace.span.end();
+		}
+	}
 };
 //#endregion
 //#region src/debug/hash.ts