@tangle-network/agent-eval 0.137.0 → 0.139.0

package/dist/tools-DZk2Jn64.js

@@ -1,1876 +0,0 @@
-import { a as LimitExceededError, c as ValidationError, n as CaptureIntegrityError, o as NotFoundError, t as AgentEvalError } from "./errors-D-LKuDhb.js";
-import { INPUT_VALUE, LLM_MODEL_ATTR_KEYS, OUTPUT_VALUE, SPAN_KIND_ATTR_KEYS, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS } from "./trace-attributes.js";
-import { AxJSRuntime, agent } from "@ax-llm/ax";
-import { z } from "zod";
-import { readFile, stat } from "node:fs/promises";
-import { RE2JS } from "re2js";
-//#region src/trace/otlp-attributes.ts
-/** Canonical OpenInference-over-OTLP attribute vocabulary used at the trace boundary. */
-const TOOL_SPAN_ATTRIBUTE_KEYS = [
-	TOOL_NAME,
-	TOOL_ARGS_CAPTURED,
-	TOOL_LATENCY_MS,
-	INPUT_VALUE,
-	OUTPUT_VALUE
-];
-const EXPLICIT_SPAN_ROLES = /* @__PURE__ */ new Set([
-	"AGENT",
-	"CHAIN",
-	"EVALUATOR",
-	"GUARDRAIL",
-	"LLM",
-	"SPAN",
-	"TOOL"
-]);
-/**
-* Classify a span once for both measurement and error accounting.
-* An explicit OpenInference kind wins; untyped spans use the same tool and
-* model signals in online and offline intake.
-*/
-function classifyOtlpSpanRole(input) {
-	const explicitKind = input.kind ?? firstStringAttribute(input.attributes, SPAN_KIND_ATTR_KEYS);
-	if (explicitKind) {
-		const normalized = explicitKind.toUpperCase();
-		if (EXPLICIT_SPAN_ROLES.has(normalized)) return normalized;
-	}
-	if (firstStringAttribute(input.attributes, TOOL_NAME_ATTR_KEYS) !== void 0 || /^(?:function|tool)[.:/]/i.test(input.name)) return "TOOL";
-	const spanType = input.attributes["span.type"];
-	if (typeof spanType === "string" && spanType.toLowerCase() === "llm_request" || /(?:^|[.:/_-])(?:chat[._-]?completions?|llm)(?:$|[.:/_-])/i.test(input.name) || firstStringAttribute(input.attributes, LLM_MODEL_ATTR_KEYS) !== void 0 || typeof input.attributes["gen_ai.operation.name"] === "string") return "LLM";
-	return "UNKNOWN";
-}
-function isOtlpModelCall(input) {
-	return classifyOtlpSpanRole(input) === "LLM";
-}
-function toolSpanOtlpAttributes(span) {
-	const argsCaptured = span.argsCaptured !== false;
-	const attributes = {
-		[TOOL_NAME]: span.toolName,
-		[TOOL_ARGS_CAPTURED]: argsCaptured
-	};
-	if (span.latencyMs !== void 0) attributes[TOOL_LATENCY_MS] = span.latencyMs;
-	if (argsCaptured) attributes[INPUT_VALUE] = stringifyTraceValue(span.args);
-	if (span.result !== void 0) attributes[OUTPUT_VALUE] = stringifyTraceValue(span.result);
-	return attributes;
-}
-function applyToolSpanOtlpAttributes(attributes, span) {
-	for (const key of TOOL_SPAN_ATTRIBUTE_KEYS) delete attributes[key];
-	Object.assign(attributes, toolSpanOtlpAttributes(span));
-}
-function traceSpanKindToOpenInferenceKind(kind) {
-	switch (kind) {
-		case "llm": return "LLM";
-		case "tool": return "TOOL";
-		case "retrieval": return "CHAIN";
-		case "judge": return "EVALUATOR";
-		case "sandbox": return "CHAIN";
-		case "agent": return "AGENT";
-		default: return "SPAN";
-	}
-}
-function firstStringAttribute(attributes, keys) {
-	for (const key of keys) {
-		const value = attributes[key];
-		if (typeof value === "string" && value.length > 0) return value;
-	}
-}
-function stringifyTraceValue(value) {
-	if (value === void 0) return "null";
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-//#endregion
-//#region src/trace-analyst/otlp-span.ts
-/**
-* Canonical OTLP-flat-line readers shared by every consumer of the
-* OTLP-JSONL wire shape (one OTLP span per line; the form
-* `flattenOtlpExportToNdjson` produces and the form AppWorld / HALO
-* emit via their OpenInference OTLP exporter).
-*
-* `OtlpFileTraceStore` indexes spans with these; `otlpToRunRecords`
-* aggregates spans into `RunRecord`s with the same readers. One parser,
-* one vocabulary — a divergence between the analyst's view of a trace and
-* the RunRecord projected from it is a class of bug this consolidation
-* removes by construction.
-*
-* Vocabulary. The readers understand BOTH dialects that appear in the
-* wild:
-*   - the substrate's own `llm.*` / `tool.*` / `span.kind` attributes
-*     (`flattenSpanAttributes` in `trace/otel.ts`), and
-*   - the OpenInference / inference-export attributes AppWorld / HALO
-*     emit (`openinference.span.kind`, `inference.observation_kind`,
-*     `inference.llm.input_tokens`, `llm.token_count.prompt`, …).
-*
-* Pure, no I/O.
-*/
-/**
-* Project one parsed OTLP-JSONL object to `ProjectedOtlpSpan`, or `null`
-* when the line is missing the mandatory `trace_id` + `span_id`.
-*/
-function projectOtlpFlatLine(raw) {
-	const trace_id = stringField(raw, "trace_id") ?? stringField(raw, "traceId");
-	const span_id = stringField(raw, "span_id") ?? stringField(raw, "spanId");
-	if (!trace_id || !span_id) return null;
-	const parent_id = normalizeParentSpanId(trace_id, span_id, stringField(raw, "parent_span_id") ?? stringField(raw, "parentSpanId") ?? null);
-	const name = stringField(raw, "name") ?? "unknown";
-	const start_time = stringField(raw, "start_time") ?? stringField(raw, "startTime") ?? "";
-	const end_time = stringField(raw, "end_time") ?? stringField(raw, "endTime") ?? start_time;
-	const status = readOtlpStatus(raw);
-	const attributes = extractOtlpAttributes(raw);
-	const service_name = asString(attributes["service.name"]) ?? asString(attributes["resource.attributes.service.name"]) ?? null;
-	const agent_name = asString(attributes["agent.name"]) ?? asString(attributes["inference.agent.name"]) ?? asString(attributes["inference.agent_name"]) ?? null;
-	const model_name = firstStringAttr(attributes, LLM_MODEL_ATTR_KEYS);
-	const tool_name = firstStringAttr(attributes, TOOL_NAME_ATTR_KEYS);
-	const kind = inferOtlpKind(attributes);
-	let duration_ms = 0;
-	if (start_time && end_time) {
-		const a = spanEpochMillis(start_time);
-		const b = spanEpochMillis(end_time);
-		if (a !== null && b !== null) duration_ms = Math.max(0, b - a);
-	}
-	return {
-		trace_id,
-		span_id,
-		parent_span_id: parent_id && parent_id.length > 0 ? parent_id : null,
-		name,
-		kind,
-		start_time,
-		end_time,
-		duration_ms,
-		status: status.code,
-		status_message: status.message,
-		service_name,
-		agent_name,
-		model_name,
-		tool_name,
-		attributes
-	};
-}
-function normalizeParentSpanId(traceId, spanId, parentId) {
-	if (!parentId) return null;
-	const prefix = `${traceId}:`;
-	return spanId.startsWith(prefix) && !parentId.startsWith(prefix) ? `${prefix}${parentId}` : parentId;
-}
-function readOtlpStatus(raw) {
-	const status = raw.status;
-	if (status && typeof status === "object" && !Array.isArray(status)) {
-		const codeRaw = status.code;
-		const code = codeRaw === "STATUS_CODE_OK" || codeRaw === "OK" ? "OK" : codeRaw === "STATUS_CODE_ERROR" || codeRaw === "ERROR" ? "ERROR" : "UNSET";
-		const messageRaw = status.message;
-		return {
-			code,
-			message: typeof messageRaw === "string" && messageRaw.length > 0 ? messageRaw : void 0
-		};
-	}
-	return {
-		code: "UNSET",
-		message: void 0
-	};
-}
-function inferOtlpKind(attrs) {
-	const opik = firstStringAttr(attrs, SPAN_KIND_ATTR_KEYS);
-	if (opik) {
-		const upper = opik.toUpperCase();
-		if (upper === "AGENT" || upper === "LLM" || upper === "TOOL" || upper === "CHAIN" || upper === "EVALUATOR" || upper === "GUARDRAIL" || upper === "SPAN") return upper;
-	}
-	return "UNKNOWN";
-}
-/**
-* Flatten OTLP `attributes` + `resource.attributes` into a single
-* dotted-key map. Span attributes override resource attributes when keys
-* overlap. Nested objects/arrays are preserved as-is.
-*/
-function extractOtlpAttributes(raw) {
-	const out = {};
-	const resource = raw.resource;
-	if (resource && typeof resource === "object" && !Array.isArray(resource)) {
-		const ra = resource.attributes;
-		if (ra && typeof ra === "object" && !Array.isArray(ra)) for (const [k, v] of Object.entries(ra)) out[k] = v;
-	}
-	const spanAttrs = raw.attributes;
-	if (spanAttrs && typeof spanAttrs === "object" && !Array.isArray(spanAttrs)) for (const [k, v] of Object.entries(spanAttrs)) out[k] = v;
-	return out;
-}
-function stringField(raw, key) {
-	const v = raw[key];
-	return typeof v === "string" ? v : void 0;
-}
-function asString(v) {
-	return typeof v === "string" && v.length > 0 ? v : null;
-}
-/** First non-empty string value across a list of candidate attribute keys. */
-function firstStringAttr(attrs, keys) {
-	for (const k of keys) {
-		const s = asString(attrs[k]);
-		if (s !== null) return s;
-	}
-	return null;
-}
-/**
-* Parse a span timestamp to epoch millis, or null when empty/unparseable. The
-* OTLP readers accept BOTH ISO-8601 and epoch-millis-string dialects, so raw
-* string comparison (`<`, `localeCompare`) mis-orders across dialects and
-* `Date.parse` returns NaN for a bare epoch-millis string.
-*/
-function spanEpochMillis(ts) {
-	if (!ts) return null;
-	if (/^\d+$/.test(ts)) return Number(ts);
-	const n = Date.parse(ts);
-	return Number.isNaN(n) ? null : n;
-}
-/**
-* Order comparator for span timestamps across mixed ISO/epoch dialects.
-* Unparseable timestamps sort as epoch 0 (earliest), never NaN (which would
-* make the sort non-deterministic).
-*/
-function compareSpanTime(a, b) {
-	return (spanEpochMillis(a) ?? 0) - (spanEpochMillis(b) ?? 0);
-}
-//#endregion
-//#region src/trace-analyst/errors.ts
-/** Invalid trace-tool arguments, including malformed filters and regexes. */
-var TraceAnalysisValidationError = class extends ValidationError {};
-/** A trace read cannot fit within a documented count or byte limit. */
-var TraceAnalysisLimitError = class extends LimitExceededError {
-	operation;
-	actual;
-	limit;
-	constructor(operation, actual, limit, message) {
-		super(message ?? `${operation} produced ${actual}, over the limit of ${limit}`);
-		this.operation = operation;
-		this.actual = actual;
-		this.limit = limit;
-	}
-};
-/** A supplied store returned a shape that violates the trace read contract. */
-var TraceAnalysisStoreContractError = class extends AgentEvalError {
-	operation;
-	constructor(operation, message, options) {
-		super("backend_integrity", `${operation}: ${message}`, options);
-		this.operation = operation;
-	}
-};
-var TraceFileMissingError = class extends NotFoundError {
-	path;
-	constructor(path) {
-		super(`trace file not found: ${path}`);
-		this.path = path;
-	}
-};
-var TraceFileTooLargeError = class extends TraceAnalysisLimitError {
-	path;
-	size_bytes;
-	max_bytes;
-	constructor(path, size_bytes, max_bytes) {
-		super("OtlpFileTraceStore.readBuffer", size_bytes, max_bytes, `trace file ${path} is ${size_bytes} bytes, over the ${max_bytes}-byte limit; raise OtlpFileTraceStoreOptions.maxFileBytes or pre-split the file`);
-		this.path = path;
-		this.size_bytes = size_bytes;
-		this.max_bytes = max_bytes;
-	}
-};
-var TraceFileMalformedError = class extends CaptureIntegrityError {
-	path;
-	line_number;
-	byte_offset;
-	constructor(path, line_number, byte_offset, cause) {
-		super(`malformed trace row in ${path} at line ${line_number}, byte ${byte_offset}`, { cause });
-		this.path = path;
-		this.line_number = line_number;
-		this.byte_offset = byte_offset;
-	}
-};
-var TraceNotFoundError = class extends NotFoundError {
-	trace_id;
-	constructor(trace_id) {
-		super(`trace not found: ${trace_id}`);
-		this.trace_id = trace_id;
-	}
-};
-var SpanNotFoundError = class extends NotFoundError {
-	trace_id;
-	span_id;
-	constructor(trace_id, span_id) {
-		super(`span ${span_id} not found in trace ${trace_id}`);
-		this.trace_id = trace_id;
-		this.span_id = span_id;
-	}
-};
-//#endregion
-//#region src/trace-analyst/shared-abortable-task.ts
-function createSharedAbortableTask(factory) {
-	const controller = new AbortController();
-	const task = {
-		controller,
-		promise: factory(controller.signal),
-		consumers: 0,
-		settled: false
-	};
-	task.promise.then(() => {
-		task.settled = true;
-	}, () => {
-		task.settled = true;
-	});
-	return task;
-}
-function waitForSharedTask(task, signal) {
-	signal?.throwIfAborted();
-	task.consumers += 1;
-	return new Promise((resolve, reject) => {
-		let finished = false;
-		const finish = (callback) => {
-			if (finished) return;
-			finished = true;
-			signal?.removeEventListener("abort", onAbort);
-			task.consumers -= 1;
-			callback();
-		};
-		const onAbort = () => {
-			finish(() => {
-				reject(signal?.reason);
-				if (!task.settled && task.consumers === 0) task.controller.abort(signal?.reason);
-			});
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-		task.promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
-		if (signal?.aborted) onAbort();
-	});
-}
-//#endregion
-//#region src/trace-analyst/store-contract.ts
-const TRACE_ANALYSIS_LIMITS = {
-	sampleTraceIds: 20,
-	queryTraces: 200,
-	viewSpans: 100,
-	searchMatches: 500,
-	filterValues: 100,
-	identifierCharacters: 256,
-	regexCharacters: 4096,
-	minimumTextBudget: 64
-};
-//#endregion
-//#region src/trace-analyst/types.ts
-const DEFAULT_TRACE_ANALYST_BUDGETS = {
-	perCallByteCeiling: 15e4,
-	perAttributeViewBudget: 4096,
-	perAttributeSpanBudget: 16384,
-	perMatchTextBudget: 1024
-};
-/** Marker substituted in place of truncated string payloads. Callers
-*  parsing tool output can detect it deterministically. */
-const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
-//#endregion
-//#region src/trace-analyst/store-bounds.ts
-function resolveTraceBudgets(overrides) {
-	const budgets = {
-		...DEFAULT_TRACE_ANALYST_BUDGETS,
-		...overrides
-	};
-	validateInteger(budgets.perCallByteCeiling, "perCallByteCeiling", 1);
-	for (const name of [
-		"perAttributeViewBudget",
-		"perAttributeSpanBudget",
-		"perMatchTextBudget"
-	]) validateInteger(budgets[name], name, TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-	return budgets;
-}
-function boundOverview(result, byteCeiling) {
-	if (result.sample_trace_ids.length > result.total_traces) throw contractError("getOverview", "sample_trace_ids contains more entries than total_traces");
-	if (result.errors.trace_count > result.total_traces) throw contractError("getOverview", "errors.trace_count exceeds total_traces");
-	return withinByteCeiling("getOverview", result, byteCeiling);
-}
-function boundTracePage(result, input, byteCeiling) {
-	if (result.traces.length > input.limit) throw contractError("queryTraces", `store returned ${result.traces.length} traces for limit ${input.limit}`);
-	if (result.total < input.offset + result.traces.length) throw contractError("queryTraces", `total ${result.total} is smaller than the returned page ending at ${input.offset + result.traces.length}`);
-	if (result.has_more !== input.offset + result.traces.length < result.total) throw contractError("queryTraces", "has_more does not match the returned page position and total");
-	if (result.has_more && result.traces.length === 0) throw contractError("queryTraces", "store reported more traces without returning any progress");
-	const traces = [];
-	for (const trace of result.traces) {
-		if (encodedBytes("queryTraces", {
-			traces: [...traces, trace],
-			total: result.total,
-			has_more: true
-		}) > byteCeiling) break;
-		traces.push(trace);
-	}
-	if (result.traces.length > 0 && traces.length === 0) throw responseItemTooLarge("queryTraces", {
-		traces: [result.traces[0]],
-		total: result.total,
-		has_more: true
-	}, byteCeiling);
-	return withinByteCeiling("queryTraces", {
-		traces,
-		total: result.total,
-		has_more: result.has_more || traces.length < result.traces.length
-	}, byteCeiling);
-}
-function boundTraceView(result, expectedTraceId, perAttributeCap, byteCeiling) {
-	requireEqual("viewTrace", "trace_id", result.trace_id, expectedTraceId);
-	if (result.oversized) return withinByteCeiling("viewTrace", result, byteCeiling);
-	const spans = result.spans.map((span) => {
-		requireEqual("viewTrace", "span.trace_id", span.trace_id, expectedTraceId);
-		return truncateSpanAttributes("viewTrace", span, perAttributeCap).span;
-	});
-	const full = {
-		trace_id: expectedTraceId,
-		spans
-	};
-	if (encodedBytes("viewTrace", full) <= byteCeiling) return full;
-	return withinByteCeiling("viewTrace", {
-		trace_id: expectedTraceId,
-		oversized: oversizedFromSpans(spans)
-	}, byteCeiling);
-}
-function boundSpansView(result, expectedTraceId, requested, existingSpanIds, perAttributeCap, byteCeiling) {
-	requireEqual("viewSpans", "trace_id", result.trace_id, expectedTraceId);
-	const requestedSet = new Set(requested);
-	const missing = checkedAccountingIds("missing_span_ids", result.missing_span_ids, requestedSet);
-	const omitted = checkedAccountingIds("omitted_span_ids", result.omitted_span_ids, requestedSet);
-	const missingSet = new Set(missing);
-	const omittedSet = new Set(omitted);
-	const expectedMissing = requested.filter((id) => !existingSpanIds.has(id));
-	if (expectedMissing.length !== missing.length || expectedMissing.some((id) => !missingSet.has(id))) throw contractError("viewSpans", "missing_span_ids does not match the store existence checks");
-	if (result.has_more !== omitted.length > 0) throw contractError("viewSpans", "has_more must be true exactly when omitted_span_ids is non-empty");
-	if (result.spans.length === 0 && requested.some((id) => existingSpanIds.has(id) && omittedSet.has(id))) throw contractError("viewSpans", "store omitted every existing requested span instead of returning progress or throwing a size error");
-	const projected = /* @__PURE__ */ new Map();
-	for (const span of result.spans) {
-		requireEqual("viewSpans", "span.trace_id", span.trace_id, expectedTraceId);
-		if (!requestedSet.has(span.span_id)) throw contractError("viewSpans", `store returned unrequested span ${JSON.stringify(span.span_id)}`);
-		if (missingSet.has(span.span_id) || omittedSet.has(span.span_id)) throw contractError("viewSpans", `span ${JSON.stringify(span.span_id)} is both returned and unavailable`);
-		if (projected.has(span.span_id)) throw contractError("viewSpans", `store returned duplicate span ${JSON.stringify(span.span_id)}`);
-		projected.set(span.span_id, truncateSpanAttributes("viewSpans", span, perAttributeCap));
-	}
-	for (const id of requested) if (!missingSet.has(id) && !omittedSet.has(id) && !projected.has(id)) throw contractError("viewSpans", `store did not account for requested span ${JSON.stringify(id)}`);
-	const spans = [];
-	let addedTruncations = 0;
-	const build = () => ({
-		trace_id: expectedTraceId,
-		spans,
-		missing_span_ids: requested.filter((id) => missingSet.has(id)),
-		omitted_span_ids: requested.filter((id) => omittedSet.has(id)),
-		has_more: omittedSet.size > 0,
-		truncated_attribute_count: result.truncated_attribute_count + addedTruncations
-	});
-	withinByteCeiling("viewSpans", build(), byteCeiling);
-	for (const id of requested) {
-		const item = projected.get(id);
-		if (!item) continue;
-		spans.push(item.span);
-		omittedSet.delete(id);
-		addedTruncations += item.truncations;
-		if (encodedBytes("viewSpans", build()) <= byteCeiling) continue;
-		spans.pop();
-		omittedSet.add(id);
-		addedTruncations -= item.truncations;
-	}
-	if (projected.size > 0 && spans.length === 0) {
-		const first = projected.values().next().value;
-		if (first) throw responseItemTooLarge("viewSpans", {
-			trace_id: expectedTraceId,
-			spans: [first.span],
-			missing_span_ids: [],
-			omitted_span_ids: [],
-			has_more: false,
-			truncated_attribute_count: result.truncated_attribute_count + first.truncations
-		}, byteCeiling);
-	}
-	return withinByteCeiling("viewSpans", build(), byteCeiling);
-}
-function boundTraceSearch(result, expectedTraceId, maxMatches, budgets) {
-	requireEqual("searchTrace", "trace_id", result.trace_id, expectedTraceId);
-	return {
-		trace_id: expectedTraceId,
-		...boundSearchHits("searchTrace", result, maxMatches, budgets, (hit) => {
-			requireEqual("searchTrace", "hit.trace_id", hit.trace_id, expectedTraceId);
-		})
-	};
-}
-function boundSpanSearch(result, expectedTraceId, expectedSpanId, maxMatches, budgets) {
-	requireEqual("searchSpan", "trace_id", result.trace_id, expectedTraceId);
-	requireEqual("searchSpan", "span_id", result.span_id, expectedSpanId);
-	return {
-		trace_id: expectedTraceId,
-		span_id: expectedSpanId,
-		...boundSearchHits("searchSpan", result, maxMatches, budgets, (hit) => {
-			requireEqual("searchSpan", "hit.trace_id", hit.trace_id, expectedTraceId);
-			requireEqual("searchSpan", "hit.span_id", hit.span_id, expectedSpanId);
-		})
-	};
-}
-function boundSearchHits(operation, result, maxMatches, budgets, validateHit) {
-	if (result.hits.length > maxMatches) throw contractError(operation, `store returned ${result.hits.length} hits for max_matches ${maxMatches}`);
-	if (result.has_more && result.hits.length === 0) throw contractError(operation, "store reported more matches without returning any progress");
-	const hits = [];
-	for (const raw of result.hits) {
-		validateHit(raw);
-		const hit = truncateMatchRecord(raw, budgets.perMatchTextBudget);
-		if (encodedBytes(operation, {
-			hits: [...hits, hit],
-			has_more: true
-		}) > budgets.perCallByteCeiling) break;
-		hits.push(hit);
-	}
-	if (result.hits.length > 0 && hits.length === 0) throw responseItemTooLarge(operation, {
-		hits: [truncateMatchRecord(result.hits[0], budgets.perMatchTextBudget)],
-		has_more: true
-	}, budgets.perCallByteCeiling);
-	return withinByteCeiling(operation, {
-		hits,
-		has_more: result.has_more || hits.length < result.hits.length
-	}, budgets.perCallByteCeiling);
-}
-function checkedAccountingIds(label, ids, requested) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const id of ids) {
-		if (!requested.has(id)) throw contractError("viewSpans", `${label} contains unrequested id ${JSON.stringify(id)}`);
-		if (seen.has(id)) throw contractError("viewSpans", `${label} contains duplicate id ${JSON.stringify(id)}`);
-		seen.add(id);
-	}
-	return [...ids];
-}
-function truncateMatchRecord(record, cap) {
-	return {
-		...record,
-		span_name: truncateForBudget(record.span_name, cap),
-		attribute_path: truncateForBudget(record.attribute_path, cap),
-		matched_text: truncateForBudget(record.matched_text, cap),
-		context_before: truncateForBudget(record.context_before, cap),
-		context_after: truncateForBudget(record.context_after, cap)
-	};
-}
-function truncateSpanAttributes(operation, span, cap) {
-	const attributes = {};
-	let truncations = 0;
-	for (const [key, value] of Object.entries(span.attributes)) {
-		if (typeof value === "string") {
-			const truncated = truncateForBudget(value, cap);
-			if (truncated !== value) truncations += 1;
-			attributes[key] = truncated;
-			continue;
-		}
-		if (value !== null && typeof value === "object") {
-			let json;
-			try {
-				json = JSON.stringify(value);
-			} catch (cause) {
-				throw new TraceAnalysisStoreContractError(operation, `span attribute ${JSON.stringify(key)} is not JSON-serializable`, { cause });
-			}
-			const truncated = truncateForBudget(json, cap);
-			if (truncated !== json) {
-				truncations += 1;
-				attributes[key] = truncated;
-			} else attributes[key] = value;
-			continue;
-		}
-		attributes[key] = value;
-	}
-	return {
-		span: {
-			...span,
-			attributes
-		},
-		truncations
-	};
-}
-function oversizedFromSpans(spans) {
-	const names = /* @__PURE__ */ new Map();
-	let maxBytes = 0;
-	let errors = 0;
-	for (const span of spans) {
-		names.set(span.name, (names.get(span.name) ?? 0) + 1);
-		maxBytes = Math.max(maxBytes, encodedBytes("viewTrace", span));
-		if (span.status === "ERROR") errors += 1;
-	}
-	return {
-		span_count: spans.length,
-		top_span_names: [...names.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 20),
-		span_response_bytes_max: maxBytes,
-		error_span_count: errors
-	};
-}
-function compileSearchRegex(pattern) {
-	if (typeof pattern !== "string" || pattern.length === 0) throw new TraceAnalysisValidationError("regex_pattern must be a non-empty string");
-	let source = pattern;
-	let flags = RE2JS.MULTILINE;
-	if (source.startsWith("(?i)")) {
-		source = source.slice(4);
-		flags |= RE2JS.CASE_INSENSITIVE;
-	}
-	try {
-		return RE2JS.compile(source, flags);
-	} catch (cause) {
-		throw new TraceAnalysisValidationError(`regex_pattern is invalid: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-	}
-}
-function truncateForBudget(value, byteCap) {
-	validateInteger(byteCap, "byteCap", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-	const original = Buffer.byteLength(value, "utf8");
-	if (original <= byteCap) return value;
-	const marker = `\n[trace-analyst truncated: original ${original} bytes]`;
-	const contentCap = byteCap - Buffer.byteLength(marker, "utf8");
-	let cut = Math.max(0, Math.floor(value.length * contentCap / original));
-	while (cut > 0 && Buffer.byteLength(value.slice(0, cut), "utf8") > contentCap) cut -= 1;
-	return `${value.slice(0, cut)}${marker}`;
-}
-function validateInteger(value, label, minimum, maximum = Number.MAX_SAFE_INTEGER) {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum) throw new TraceAnalysisValidationError(`${label} must be an integer ${minimum}..${maximum}, got ${String(value)}`);
-	return value;
-}
-function requireEqual(operation, label, actual, expected) {
-	if (actual !== expected) throw contractError(operation, `${label} ${JSON.stringify(actual)} does not match ${JSON.stringify(expected)}`);
-}
-function encodedBytes(operation, value) {
-	try {
-		const encoded = JSON.stringify(value);
-		if (encoded === void 0) throw new TypeError("JSON.stringify returned undefined");
-		return Buffer.byteLength(encoded, "utf8");
-	} catch (cause) {
-		if (cause instanceof TraceAnalysisStoreContractError) throw cause;
-		throw new TraceAnalysisStoreContractError(operation, "store result is not JSON-serializable", { cause });
-	}
-}
-function withinByteCeiling(operation, value, ceiling) {
-	const actual = encodedBytes(operation, value);
-	if (actual > ceiling) throw new TraceAnalysisLimitError(operation, actual, ceiling, `${operation} metadata requires ${actual} bytes, over the ${ceiling}-byte response limit`);
-	return value;
-}
-function responseItemTooLarge(operation, value, ceiling) {
-	return new TraceAnalysisLimitError(operation, encodedBytes(operation, value), ceiling, `${operation} cannot fit one result item in the ${ceiling}-byte response limit`);
-}
-function contractError(operation, message) {
-	return new TraceAnalysisStoreContractError(operation, message);
-}
-//#endregion
-//#region src/trace-analyst/store-schemas.ts
-const identifier = z.string().min(1).max(TRACE_ANALYSIS_LIMITS.identifierCharacters);
-const timestamp = z.iso.datetime({ offset: true });
-const nonNegativeInteger = z.number().int().nonnegative();
-const nonNegativeNumber = z.number().nonnegative();
-const nullableString = z.string().nullable();
-const nullableIdentifier = identifier.nullable();
-const stringArray = z.array(z.string());
-const filterValues = z.array(identifier).max(TRACE_ANALYSIS_LIMITS.filterValues);
-const traceFiltersSchema = z.object({
-	has_errors: z.boolean().optional(),
-	service_names: filterValues.optional(),
-	agent_names: filterValues.optional(),
-	model_names: filterValues.optional(),
-	tool_names: filterValues.optional(),
-	start_time_after: timestamp.optional(),
-	start_time_before: timestamp.optional(),
-	regex_pattern: z.string().min(1).max(TRACE_ANALYSIS_LIMITS.regexCharacters).optional()
-}).strict();
-const byteCap = z.number().int().min(TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-const searchPattern = z.string().min(1).max(TRACE_ANALYSIS_LIMITS.regexCharacters);
-const traceStoreInputSchemas = {
-	hasTrace: z.object({ trace_id: identifier }).strict(),
-	hasSpans: z.object({
-		trace_id: identifier,
-		span_ids: z.array(identifier).min(1).max(TRACE_ANALYSIS_LIMITS.viewSpans)
-	}).strict(),
-	getOverview: z.object({ filters: traceFiltersSchema.optional() }).strict(),
-	queryTraces: z.object({
-		filters: traceFiltersSchema.optional(),
-		limit: z.number().int().min(1).max(TRACE_ANALYSIS_LIMITS.queryTraces),
-		offset: z.number().int().nonnegative().optional()
-	}).strict(),
-	countTraces: z.object({ filters: traceFiltersSchema.optional() }).strict(),
-	viewTrace: z.object({
-		trace_id: identifier,
-		per_attribute_byte_cap: byteCap.optional()
-	}).strict(),
-	viewSpans: z.object({
-		trace_id: identifier,
-		span_ids: z.array(identifier).min(1).max(TRACE_ANALYSIS_LIMITS.viewSpans),
-		per_attribute_byte_cap: byteCap.optional()
-	}).strict(),
-	searchTrace: z.object({
-		trace_id: identifier,
-		regex_pattern: searchPattern,
-		max_matches: z.number().int().min(1).max(TRACE_ANALYSIS_LIMITS.searchMatches).default(50)
-	}).strict(),
-	searchSpan: z.object({
-		trace_id: identifier,
-		span_id: identifier,
-		regex_pattern: searchPattern,
-		max_matches: z.number().int().min(1).max(TRACE_ANALYSIS_LIMITS.searchMatches).default(50)
-	}).strict()
-};
-const spanKind = z.enum([
-	"AGENT",
-	"LLM",
-	"TOOL",
-	"CHAIN",
-	"EVALUATOR",
-	"GUARDRAIL",
-	"SPAN",
-	"UNKNOWN"
-]);
-const spanStatus = z.enum([
-	"OK",
-	"ERROR",
-	"UNSET"
-]);
-const traceSpan = z.object({
-	trace_id: identifier,
-	span_id: identifier,
-	parent_span_id: nullableIdentifier,
-	name: z.string(),
-	kind: spanKind,
-	start_time: timestamp,
-	end_time: timestamp,
-	duration_ms: nonNegativeNumber,
-	status: spanStatus,
-	status_message: z.string().optional(),
-	service_name: nullableString,
-	agent_name: nullableString,
-	model_name: nullableString,
-	tool_name: nullableString,
-	attributes: z.record(z.string(), z.json())
-}).strict();
-const traceSummary = z.object({
-	trace_id: identifier,
-	service_name: nullableString,
-	agent_name: nullableString,
-	span_count: nonNegativeInteger,
-	has_errors: z.boolean(),
-	start_time: timestamp,
-	end_time: timestamp,
-	duration_ms: nonNegativeNumber,
-	raw_jsonl_bytes: nonNegativeInteger,
-	models: stringArray,
-	tools: stringArray
-}).strict();
-const errorCluster = z.object({
-	signature: z.string(),
-	status_message_sample: z.string(),
-	span_name: nullableString,
-	tool_name: nullableString,
-	trace_count: nonNegativeInteger,
-	span_count: nonNegativeInteger,
-	prevalence: z.number().min(0).max(1),
-	exemplar_trace_ids: z.array(identifier),
-	exemplar_span_ids: z.array(identifier)
-}).strict();
-const overview = z.object({
-	total_traces: nonNegativeInteger,
-	raw_jsonl_bytes: nonNegativeInteger,
-	services: stringArray,
-	agents: stringArray,
-	models: stringArray,
-	tool_names: stringArray,
-	sample_trace_ids: z.array(identifier).max(TRACE_ANALYSIS_LIMITS.sampleTraceIds),
-	errors: z.object({
-		trace_count: nonNegativeInteger,
-		span_count: nonNegativeInteger
-	}).strict(),
-	error_clusters: z.array(errorCluster),
-	time_range: z.object({
-		earliest: timestamp,
-		latest: timestamp
-	}).strict().nullable()
-}).strict();
-const tracePage = z.object({
-	traces: z.array(traceSummary),
-	total: nonNegativeInteger,
-	has_more: z.boolean()
-}).strict();
-const oversizedTrace = z.object({
-	span_count: nonNegativeInteger,
-	top_span_names: z.array(z.tuple([z.string(), nonNegativeInteger])).max(20),
-	span_response_bytes_max: nonNegativeInteger,
-	error_span_count: nonNegativeInteger
-}).strict();
-const traceView = z.object({
-	trace_id: identifier,
-	spans: z.array(traceSpan).optional(),
-	oversized: oversizedTrace.optional()
-}).strict().refine((value) => value.spans === void 0 !== (value.oversized === void 0), { message: "exactly one of spans or oversized is required" });
-const spansView = z.object({
-	trace_id: identifier,
-	spans: z.array(traceSpan),
-	missing_span_ids: z.array(identifier),
-	omitted_span_ids: z.array(identifier),
-	has_more: z.boolean(),
-	truncated_attribute_count: nonNegativeInteger
-}).strict();
-const matchRecord = z.object({
-	trace_id: identifier,
-	span_id: identifier,
-	span_name: z.string(),
-	span_kind: spanKind,
-	attribute_path: z.string(),
-	matched_text: z.string(),
-	context_before: z.string(),
-	context_after: z.string(),
-	match_offset: nonNegativeInteger
-}).strict();
-const traceSearch = z.object({
-	trace_id: identifier,
-	hits: z.array(matchRecord),
-	has_more: z.boolean()
-}).strict();
-const spanSearch = traceSearch.extend({ span_id: identifier }).strict();
-const traceStoreOutputSchemas = {
-	hasTrace: z.boolean(),
-	hasSpans: z.array(identifier).max(TRACE_ANALYSIS_LIMITS.viewSpans),
-	getOverview: overview,
-	queryTraces: tracePage,
-	countTraces: nonNegativeInteger,
-	viewTrace: traceView,
-	viewSpans: spansView,
-	searchTrace: traceSearch,
-	searchSpan: spanSearch
-};
-function parseTraceInput(operation, schema, value) {
-	try {
-		return schema.parse(value);
-	} catch (cause) {
-		throw new TraceAnalysisValidationError(`${operation}: invalid arguments: ${cause instanceof z.ZodError ? z.prettifyError(cause) : String(cause)}`, { cause });
-	}
-}
-function parseStoreOutput(operation, schema, value) {
-	try {
-		return schema.parse(value);
-	} catch (cause) {
-		throw new TraceAnalysisStoreContractError(operation, `invalid store result: ${cause instanceof z.ZodError ? z.prettifyError(cause) : String(cause)}`, { cause });
-	}
-}
-function toTraceJsonSchema(schema) {
-	return z.toJSONSchema(schema, { target: "draft-7" });
-}
-//#endregion
-//#region src/trace-analyst/store-boundary.ts
-/** Apply the public validation, cancellation, not-found, and size rules to any adapter. */
-function createBoundedTraceAnalysisStore(source, options = {}) {
-	const budgets = resolveTraceBudgets(options.budgets);
-	return {
-		async hasTrace(traceId, context) {
-			throwIfAborted(context);
-			const { trace_id } = parseTraceInput("hasTrace", traceStoreInputSchemas.hasTrace, { trace_id: traceId });
-			const result = await source.hasTrace(trace_id, context);
-			throwIfAborted(context);
-			return parseStoreOutput("hasTrace", traceStoreOutputSchemas.hasTrace, result);
-		},
-		async hasSpans(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("hasSpans", traceStoreInputSchemas.hasSpans, input);
-			assertUniqueIds(parsed.span_ids, "hasSpans.span_ids");
-			const result = await source.hasSpans(parsed, context);
-			throwIfAborted(context);
-			return validateExistingSpanIds(parseStoreOutput("hasSpans", traceStoreOutputSchemas.hasSpans, result), parsed.span_ids);
-		},
-		async getOverview(filters, context) {
-			throwIfAborted(context);
-			const input = parseTraceInput("getOverview", traceStoreInputSchemas.getOverview, { filters });
-			const result = await source.getOverview(input.filters, context);
-			throwIfAborted(context);
-			return boundOverview(parseStoreOutput("getOverview", traceStoreOutputSchemas.getOverview, result), budgets.perCallByteCeiling);
-		},
-		async queryTraces(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("queryTraces", traceStoreInputSchemas.queryTraces, input);
-			const offset = parsed.offset ?? 0;
-			const result = await source.queryTraces({
-				...parsed,
-				offset
-			}, context);
-			throwIfAborted(context);
-			return boundTracePage(parseStoreOutput("queryTraces", traceStoreOutputSchemas.queryTraces, result), {
-				limit: parsed.limit,
-				offset
-			}, budgets.perCallByteCeiling);
-		},
-		async countTraces(filters, context) {
-			throwIfAborted(context);
-			const input = parseTraceInput("countTraces", traceStoreInputSchemas.countTraces, { filters });
-			const result = await source.countTraces(input.filters, context);
-			throwIfAborted(context);
-			return parseStoreOutput("countTraces", traceStoreOutputSchemas.countTraces, result);
-		},
-		async viewTrace(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("viewTrace", traceStoreInputSchemas.viewTrace, input);
-			await requireTrace(source, parsed.trace_id, context);
-			const perAttributeCap = parsed.per_attribute_byte_cap ?? budgets.perAttributeViewBudget;
-			const result = await source.viewTrace({
-				...parsed,
-				per_attribute_byte_cap: perAttributeCap
-			}, context);
-			throwIfAborted(context);
-			return boundTraceView(parseStoreOutput("viewTrace", traceStoreOutputSchemas.viewTrace, result), parsed.trace_id, perAttributeCap, budgets.perCallByteCeiling);
-		},
-		async viewSpans(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("viewSpans", traceStoreInputSchemas.viewSpans, input);
-			assertUniqueIds(parsed.span_ids, "viewSpans.span_ids");
-			await requireTrace(source, parsed.trace_id, context);
-			const existingSpanIds = new Set(validateExistingSpanIds(parseStoreOutput("hasSpans", traceStoreOutputSchemas.hasSpans, await source.hasSpans({
-				trace_id: parsed.trace_id,
-				span_ids: parsed.span_ids
-			}, context)), parsed.span_ids));
-			throwIfAborted(context);
-			const perAttributeCap = parsed.per_attribute_byte_cap ?? budgets.perAttributeSpanBudget;
-			const result = await source.viewSpans({
-				...parsed,
-				per_attribute_byte_cap: perAttributeCap
-			}, context);
-			throwIfAborted(context);
-			return boundSpansView(parseStoreOutput("viewSpans", traceStoreOutputSchemas.viewSpans, result), parsed.trace_id, parsed.span_ids, existingSpanIds, perAttributeCap, budgets.perCallByteCeiling);
-		},
-		async searchTrace(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("searchTrace", traceStoreInputSchemas.searchTrace, input);
-			compileSearchRegex(parsed.regex_pattern);
-			await requireTrace(source, parsed.trace_id, context);
-			const result = await source.searchTrace(parsed, context);
-			throwIfAborted(context);
-			return boundTraceSearch(parseStoreOutput("searchTrace", traceStoreOutputSchemas.searchTrace, result), parsed.trace_id, parsed.max_matches, budgets);
-		},
-		async searchSpan(input, context) {
-			throwIfAborted(context);
-			const parsed = parseTraceInput("searchSpan", traceStoreInputSchemas.searchSpan, input);
-			compileSearchRegex(parsed.regex_pattern);
-			await requireTrace(source, parsed.trace_id, context);
-			await requireSpan(source, parsed.trace_id, parsed.span_id, context);
-			const result = await source.searchSpan(parsed, context);
-			throwIfAborted(context);
-			return boundSpanSearch(parseStoreOutput("searchSpan", traceStoreOutputSchemas.searchSpan, result), parsed.trace_id, parsed.span_id, parsed.max_matches, budgets);
-		}
-	};
-}
-async function requireTrace(source, traceId, context) {
-	throwIfAborted(context);
-	const exists = await source.hasTrace(traceId, context);
-	throwIfAborted(context);
-	if (!parseStoreOutput("hasTrace", traceStoreOutputSchemas.hasTrace, exists)) throw new TraceNotFoundError(traceId);
-}
-async function requireSpan(source, traceId, spanId, context) {
-	throwIfAborted(context);
-	const existing = await source.hasSpans({
-		trace_id: traceId,
-		span_ids: [spanId]
-	}, context);
-	throwIfAborted(context);
-	if (validateExistingSpanIds(parseStoreOutput("hasSpans", traceStoreOutputSchemas.hasSpans, existing), [spanId]).length === 0) throw new SpanNotFoundError(traceId, spanId);
-}
-function validateExistingSpanIds(found, requested) {
-	const requestedSet = new Set(requested);
-	const seen = /* @__PURE__ */ new Set();
-	for (const id of found) {
-		if (!requestedSet.has(id)) throw new TraceAnalysisStoreContractError("hasSpans", `hasSpans returned unrequested span id ${JSON.stringify(id)}`);
-		if (seen.has(id)) throw new TraceAnalysisStoreContractError("hasSpans", `hasSpans returned duplicate span id ${JSON.stringify(id)}`);
-		seen.add(id);
-	}
-	return [...found];
-}
-function assertUniqueIds(ids, label) {
-	if (new Set(ids).size !== ids.length) throw new TraceAnalysisValidationError(`${label} must not contain duplicates`);
-}
-function throwIfAborted(context) {
-	context?.signal?.throwIfAborted();
-}
-//#endregion
-//#region src/trace-analyst/store-otlp.ts
-/**
-* `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the
-* trace-analyst.
-*
-* Wire shape. Each line of the input file is one OTLP-shaped span. The
-* store understands flattened OTLP JSONL plus the OpenInference vocab.
-* We project upstream's full
-* span shape down to `TraceAnalystSpan` lazily — full materialisation
-* only happens for the spans the agent actually requests.
-*
-* Indexing. On first read the store builds an in-memory index keyed
-* by `trace_id` carrying:
-*   - byte offsets + lengths for each span line (for surgical reads
-*     without re-parsing the whole file)
-*   - a `TraceAnalystTraceSummary` rollup
-*   - sets of services / agents / models / tools / has_errors
-*   - byte size of the trace's JSONL slab
-*
-* Memory bound. The index keeps span metadata only — names, kinds,
-* offsets, status. Attribute payloads stay on disk until requested.
-* For a 50MB JSONL with 50k spans, the index is ~5MB.
-*
-* Concurrency. The store builds the index once on first read and
-* caches it. Subsequent reads reuse the index. The file is opened on
-* each read; we never hold a long-lived FD.
-*/
-/** Lines indexed between event-loop yields. Bounded synchronous work per
-*  tick keeps the index build from starving other tasks on large files
-*  while staying coarse enough that the yields are cheap. */
-const INDEX_YIELD_LINES = 5e3;
-const SCAN_YIELD_ITEMS = 500;
-/** Hand control back to the event loop without busy-waiting. */
-function yieldToEventLoop() {
-	return new Promise((resolve) => setImmediate(resolve));
-}
-async function scanCheckpoint(signal, item) {
-	signal?.throwIfAborted();
-	if (item > 0 && item % SCAN_YIELD_ITEMS === 0) {
-		await yieldToEventLoop();
-		signal?.throwIfAborted();
-	}
-}
-var BufferedOtlpTraceStore = class {
-	perAttributeViewBudget;
-	perAttributeSpanBudget;
-	perCallByteCeiling;
-	perMatchTextBudget;
-	indexValue;
-	indexTask;
-	bufferValue;
-	bufferTask;
-	constructor(opts) {
-		this.perAttributeViewBudget = validateInteger(opts.perAttributeViewBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeViewBudget, "perAttributeViewBudget", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-		this.perAttributeSpanBudget = validateInteger(opts.perAttributeSpanBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeSpanBudget, "perAttributeSpanBudget", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-		this.perCallByteCeiling = validateInteger(opts.perCallByteCeiling ?? DEFAULT_TRACE_ANALYST_BUDGETS.perCallByteCeiling, "perCallByteCeiling", 1);
-		this.perMatchTextBudget = validateInteger(opts.perMatchTextBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perMatchTextBudget, "perMatchTextBudget", TRACE_ANALYSIS_LIMITS.minimumTextBudget);
-	}
-	async hasTrace(trace_id, context) {
-		context?.signal?.throwIfAborted();
-		const idx = await this.index(context);
-		context?.signal?.throwIfAborted();
-		return idx.byTrace.has(trace_id);
-	}
-	async hasSpans(opts, context) {
-		context?.signal?.throwIfAborted();
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) return [];
-		const requested = new Set(opts.span_ids);
-		const found = [];
-		for (let index = 0; index < trace.spans.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const spanId = trace.spans[index].span_id;
-			if (requested.has(spanId)) found.push(spanId);
-		}
-		return found;
-	}
-	async getOverview(filters, context) {
-		const idx = await this.index(context);
-		const matched = await this.matchedTraces(idx, filters, context);
-		const services = /* @__PURE__ */ new Set();
-		const agents = /* @__PURE__ */ new Set();
-		const models = /* @__PURE__ */ new Set();
-		const tools = /* @__PURE__ */ new Set();
-		let rawBytes = 0;
-		let earliest = null;
-		let latest = null;
-		let errorTraceCount = 0;
-		let errorSpanCount = 0;
-		const clusters = /* @__PURE__ */ new Map();
-		let traceIndex = 0;
-		for (const t of matched) {
-			await scanCheckpoint(context?.signal, traceIndex++);
-			if (t.service_name) services.add(t.service_name);
-			if (t.agent_name) agents.add(t.agent_name);
-			for (const m of t.models) models.add(m);
-			for (const tn of t.tools) tools.add(tn);
-			rawBytes += t.raw_jsonl_bytes;
-			if (!earliest || compareSpanTime(t.start_time, earliest) < 0) earliest = t.start_time;
-			if (!latest || compareSpanTime(t.end_time, latest) > 0) latest = t.end_time;
-			if (t.has_errors) {
-				errorTraceCount += 1;
-				let spanIndex = 0;
-				for (const s of t.spans) {
-					await scanCheckpoint(context?.signal, spanIndex++);
-					if (s.status !== "ERROR") continue;
-					errorSpanCount += 1;
-					accumulateErrorCluster(clusters, t.trace_id, s);
-				}
-			}
-		}
-		const sample_trace_ids = matched.slice(0, 20).map((t) => t.trace_id);
-		return {
-			total_traces: matched.length,
-			raw_jsonl_bytes: rawBytes,
-			services: [...services].sort(),
-			agents: [...agents].sort(),
-			models: [...models].sort(),
-			tool_names: [...tools].sort(),
-			sample_trace_ids,
-			errors: {
-				trace_count: errorTraceCount,
-				span_count: errorSpanCount
-			},
-			error_clusters: finalizeErrorClusters(clusters, errorTraceCount),
-			time_range: earliest && latest ? {
-				earliest,
-				latest
-			} : null
-		};
-	}
-	async queryTraces(opts, context) {
-		const limit = validateInteger(opts.limit, "queryTraces.limit", 1, TRACE_ANALYSIS_LIMITS.queryTraces);
-		const offset = validateInteger(opts.offset ?? 0, "queryTraces.offset", 0);
-		const idx = await this.index(context);
-		const matched = await this.matchedTraces(idx, opts.filters, context);
-		const slice = matched.slice(offset, offset + limit);
-		return {
-			traces: slice.map((t) => this.toSummary(t)),
-			total: matched.length,
-			has_more: offset + slice.length < matched.length
-		};
-	}
-	async countTraces(filters, context) {
-		const idx = await this.index(context);
-		return (await this.matchedTraces(idx, filters, context)).length;
-	}
-	async viewTrace(opts, context) {
-		context?.signal?.throwIfAborted();
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		const cap = validateInteger(opts.per_attribute_byte_cap ?? this.perAttributeViewBudget, "viewTrace.per_attribute_byte_cap", 1);
-		const buf = await this.buffer(context);
-		const spans = [];
-		let runningBytes = 0;
-		let span_response_bytes_max = 0;
-		const counter = { value: 0 };
-		let spanIndex = 0;
-		for (const s of trace.spans) {
-			await scanCheckpoint(context?.signal, spanIndex++);
-			const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter);
-			const bytes = Buffer.byteLength(JSON.stringify(projected), "utf8");
-			span_response_bytes_max = Math.max(span_response_bytes_max, bytes);
-			runningBytes += bytes;
-			if (runningBytes > this.perCallByteCeiling) return {
-				trace_id: trace.trace_id,
-				oversized: this.buildOversizedSummary(trace, span_response_bytes_max)
-			};
-			spans.push(projected);
-		}
-		return {
-			trace_id: trace.trace_id,
-			spans
-		};
-	}
-	async viewSpans(opts, context) {
-		context?.signal?.throwIfAborted();
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		if (opts.span_ids.length < 1 || opts.span_ids.length > TRACE_ANALYSIS_LIMITS.viewSpans) throw new TraceAnalysisValidationError(`viewSpans.span_ids must contain 1..${TRACE_ANALYSIS_LIMITS.viewSpans} ids, got ${opts.span_ids.length}`);
-		const cap = validateInteger(opts.per_attribute_byte_cap ?? this.perAttributeSpanBudget, "viewSpans.per_attribute_byte_cap", 1);
-		const requested = [...new Set(opts.span_ids)];
-		const wantSet = new Set(requested);
-		const foundById = /* @__PURE__ */ new Map();
-		for (let index = 0; index < trace.spans.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const span = trace.spans[index];
-			if (wantSet.has(span.span_id)) foundById.set(span.span_id, span);
-		}
-		const missing = requested.filter((id) => !foundById.has(id));
-		const buf = await this.buffer(context);
-		const spans = [];
-		let truncatedAttributeCount = 0;
-		const omitted = new Set(requested.filter((id) => foundById.has(id)));
-		const buildResult = () => ({
-			trace_id: trace.trace_id,
-			spans,
-			missing_span_ids: missing,
-			omitted_span_ids: requested.filter((id) => omitted.has(id)),
-			has_more: omitted.size > 0,
-			truncated_attribute_count: truncatedAttributeCount
-		});
-		const metadataBytes = Buffer.byteLength(JSON.stringify(buildResult()), "utf8");
-		if (metadataBytes > this.perCallByteCeiling) throw new TraceAnalysisLimitError("viewSpans", metadataBytes, this.perCallByteCeiling, `viewSpans accounting requires ${metadataBytes} bytes, over the ${this.perCallByteCeiling}-byte response limit`);
-		let spanIndex = 0;
-		let smallestRejectedBytes = Number.POSITIVE_INFINITY;
-		for (const id of requested) {
-			await scanCheckpoint(context?.signal, spanIndex++);
-			const s = foundById.get(id);
-			if (!s) continue;
-			const counter = { value: 0 };
-			const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter);
-			spans.push(projected);
-			omitted.delete(id);
-			truncatedAttributeCount += counter.value;
-			const responseBytes = Buffer.byteLength(JSON.stringify(buildResult()), "utf8");
-			if (responseBytes <= this.perCallByteCeiling) continue;
-			smallestRejectedBytes = Math.min(smallestRejectedBytes, responseBytes);
-			if (requested.length === 1) throw new TraceAnalysisLimitError("viewSpans", responseBytes, this.perCallByteCeiling, `viewSpans cannot fit span ${JSON.stringify(id)} in the ${this.perCallByteCeiling}-byte response limit`);
-			spans.pop();
-			omitted.add(id);
-			truncatedAttributeCount -= counter.value;
-		}
-		if (foundById.size > 0 && spans.length === 0) throw new TraceAnalysisLimitError("viewSpans", smallestRejectedBytes, this.perCallByteCeiling, `viewSpans cannot fit one requested span in the ${this.perCallByteCeiling}-byte response limit`);
-		return buildResult();
-	}
-	async searchTrace(opts, context) {
-		const max_matches = validateInteger(opts.max_matches ?? 50, "searchTrace.max_matches", 1, TRACE_ANALYSIS_LIMITS.searchMatches);
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		const re = compileSearchRegex(opts.regex_pattern);
-		const buf = await this.buffer(context);
-		const hits = [];
-		let hasMore = false;
-		let spanIndex = 0;
-		for (const s of trace.spans) {
-			await scanCheckpoint(context?.signal, spanIndex++);
-			const remaining = max_matches - hits.length;
-			const localHits = await this.scanSpanForMatches(buf, trace.trace_id, s, re, this.perMatchTextBudget, remaining, context);
-			for (const h of localHits.records) {
-				if (hits.length >= max_matches) break;
-				hits.push(h);
-			}
-			if (localHits.hasMore) {
-				hasMore = true;
-				break;
-			}
-		}
-		return {
-			trace_id: trace.trace_id,
-			hits,
-			has_more: hasMore
-		};
-	}
-	async searchSpan(opts, context) {
-		const max_matches = validateInteger(opts.max_matches ?? 50, "searchSpan.max_matches", 1, TRACE_ANALYSIS_LIMITS.searchMatches);
-		const trace = (await this.index(context)).byTrace.get(opts.trace_id);
-		if (!trace) throw new TraceNotFoundError(opts.trace_id);
-		let span;
-		for (let index = 0; index < trace.spans.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const candidate = trace.spans[index];
-			if (candidate.span_id === opts.span_id) {
-				span = candidate;
-				break;
-			}
-		}
-		if (!span) throw new SpanNotFoundError(opts.trace_id, opts.span_id);
-		const re = compileSearchRegex(opts.regex_pattern);
-		const buf = await this.buffer(context);
-		const localHits = await this.scanSpanForMatches(buf, trace.trace_id, span, re, this.perMatchTextBudget, max_matches, context);
-		return {
-			trace_id: trace.trace_id,
-			span_id: span.span_id,
-			hits: localHits.records,
-			has_more: localHits.hasMore
-		};
-	}
-	/** Force the index to materialise. Useful to amortise startup cost
-	*  before the first agent call. */
-	async ensureIndexed(context) {
-		await this.index(context);
-	}
-	async buffer(context) {
-		context?.signal?.throwIfAborted();
-		if (this.bufferValue) return this.bufferValue;
-		if (!this.bufferTask) {
-			const task = createSharedAbortableTask((signal) => this.readBuffer(signal));
-			this.bufferTask = task;
-			task.promise.then((value) => {
-				this.bufferValue = value;
-				if (this.bufferTask === task) this.bufferTask = void 0;
-			}, () => {
-				if (this.bufferTask === task) this.bufferTask = void 0;
-			});
-		}
-		return waitForSharedTask(this.bufferTask, context?.signal);
-	}
-	async index(context) {
-		context?.signal?.throwIfAborted();
-		if (this.indexValue) return this.indexValue;
-		if (!this.indexTask) {
-			const task = createSharedAbortableTask((signal) => this.buildIndex(signal));
-			this.indexTask = task;
-			task.promise.then((value) => {
-				this.indexValue = value;
-				if (this.indexTask === task) this.indexTask = void 0;
-			}, () => {
-				if (this.indexTask === task) this.indexTask = void 0;
-			});
-		}
-		return waitForSharedTask(this.indexTask, context?.signal);
-	}
-	async buildIndex(signal) {
-		const buf = await this.buffer({ signal });
-		signal?.throwIfAborted();
-		const byTrace = /* @__PURE__ */ new Map();
-		let cursor = 0;
-		let lineNumber = 0;
-		let sinceYield = 0;
-		while (cursor < buf.length) {
-			lineNumber += 1;
-			if (++sinceYield >= INDEX_YIELD_LINES) {
-				sinceYield = 0;
-				await yieldToEventLoop();
-				signal?.throwIfAborted();
-			}
-			const newlineIndex = buf.indexOf(10, cursor);
-			const lineEnd = newlineIndex === -1 ? buf.length : newlineIndex;
-			const lineLength = lineEnd - cursor;
-			if (lineLength === 0) {
-				cursor = lineEnd + 1;
-				continue;
-			}
-			const lineSlice = buf.subarray(cursor, lineEnd).toString("utf8");
-			const lineOffset = cursor;
-			cursor = lineEnd + 1;
-			let parsed;
-			try {
-				parsed = JSON.parse(lineSlice);
-			} catch (cause) {
-				throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset, cause);
-			}
-			if (!parsed || typeof parsed !== "object") throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset);
-			const span = projectOtlpFlatLine(parsed);
-			if (!span) throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset);
-			let entry = byTrace.get(span.trace_id);
-			if (!entry) {
-				entry = {
-					trace_id: span.trace_id,
-					service_name: span.service_name,
-					agent_name: span.agent_name,
-					span_count: 0,
-					has_errors: false,
-					start_time: span.start_time,
-					end_time: span.end_time,
-					duration_ms: 0,
-					raw_jsonl_bytes: 0,
-					models: /* @__PURE__ */ new Set(),
-					tools: /* @__PURE__ */ new Set(),
-					spans: []
-				};
-				byTrace.set(span.trace_id, entry);
-			} else {
-				if (!entry.service_name && span.service_name) entry.service_name = span.service_name;
-				if (!entry.agent_name && span.agent_name) entry.agent_name = span.agent_name;
-			}
-			const indexEntry = {
-				span_id: span.span_id,
-				parent_span_id: span.parent_span_id,
-				name: span.name,
-				kind: span.kind,
-				start_time: span.start_time,
-				end_time: span.end_time,
-				duration_ms: span.duration_ms,
-				status: span.status,
-				status_message: span.status_message,
-				service_name: span.service_name,
-				agent_name: span.agent_name,
-				model_name: span.model_name,
-				tool_name: span.tool_name,
-				line_byte_offset: lineOffset,
-				line_byte_length: lineLength
-			};
-			entry.spans.push(indexEntry);
-			entry.span_count += 1;
-			entry.raw_jsonl_bytes += lineLength + 1;
-			if (span.status === "ERROR") entry.has_errors = true;
-			if (compareSpanTime(span.start_time, entry.start_time) < 0) entry.start_time = span.start_time;
-			if (compareSpanTime(span.end_time, entry.end_time) > 0) entry.end_time = span.end_time;
-			if (span.model_name) entry.models.add(span.model_name);
-			if (span.tool_name) entry.tools.add(span.tool_name);
-		}
-		let totalRawBytes = 0;
-		for (const t of byTrace.values()) {
-			signal?.throwIfAborted();
-			totalRawBytes += t.raw_jsonl_bytes;
-			t.spans.sort((a, b) => compareSpanTime(a.start_time, b.start_time) || a.line_byte_offset - b.line_byte_offset);
-			const startMs = spanEpochMillis(t.start_time);
-			const endMs = spanEpochMillis(t.end_time);
-			t.duration_ms = startMs === null || endMs === null ? 0 : Math.max(0, endMs - startMs);
-		}
-		const sortedTraceIds = [...byTrace.keys()].sort();
-		signal?.throwIfAborted();
-		return {
-			byTrace,
-			totalRawBytes,
-			sortedTraceIds
-		};
-	}
-	async matchedTraces(idx, filters, context) {
-		context?.signal?.throwIfAborted();
-		const traces = [];
-		for (let index = 0; index < idx.sortedTraceIds.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const trace = idx.byTrace.get(idx.sortedTraceIds[index]);
-			if (trace) traces.push(trace);
-		}
-		if (!filters) return traces;
-		const indexedFiltered = [];
-		for (let index = 0; index < traces.length; index += 1) {
-			await scanCheckpoint(context?.signal, index);
-			const t = traces[index];
-			if (filters.has_errors !== void 0 && t.has_errors !== filters.has_errors) continue;
-			if (filters.service_names && filters.service_names.length > 0) {
-				if (!t.service_name || !filters.service_names.includes(t.service_name)) continue;
-			}
-			if (filters.agent_names && filters.agent_names.length > 0) {
-				if (!t.agent_name || !filters.agent_names.includes(t.agent_name)) continue;
-			}
-			if (filters.model_names && filters.model_names.length > 0) {
-				if (![...t.models].some((m) => filters.model_names.includes(m))) continue;
-			}
-			if (filters.tool_names && filters.tool_names.length > 0) {
-				if (![...t.tools].some((tn) => filters.tool_names.includes(tn))) continue;
-			}
-			if (filters.start_time_after && t.start_time < filters.start_time_after) continue;
-			if (filters.start_time_before && t.start_time > filters.start_time_before) continue;
-			indexedFiltered.push(t);
-		}
-		if (!filters.regex_pattern) return indexedFiltered;
-		const re = compileSearchRegex(filters.regex_pattern);
-		const buf = await this.buffer(context);
-		const out = [];
-		let traceIndex = 0;
-		for (const t of indexedFiltered) {
-			await scanCheckpoint(context?.signal, traceIndex++);
-			let matched = false;
-			let spanIndex = 0;
-			for (const s of t.spans) {
-				await scanCheckpoint(context?.signal, spanIndex++);
-				const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length);
-				if (re.test(slice.toString("utf8"))) {
-					matched = true;
-					break;
-				}
-			}
-			if (matched) out.push(t);
-		}
-		return out;
-	}
-	toSummary(t) {
-		return {
-			trace_id: t.trace_id,
-			service_name: t.service_name,
-			agent_name: t.agent_name,
-			span_count: t.span_count,
-			has_errors: t.has_errors,
-			start_time: t.start_time,
-			end_time: t.end_time,
-			duration_ms: t.duration_ms,
-			raw_jsonl_bytes: t.raw_jsonl_bytes,
-			models: [...t.models].sort(),
-			tools: [...t.tools].sort()
-		};
-	}
-	projectSpan(buf, trace_id, s, perAttrCap, counter) {
-		const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length).toString("utf8");
-		let raw = {};
-		try {
-			const parsed = JSON.parse(slice);
-			if (parsed && typeof parsed === "object") raw = parsed;
-		} catch {}
-		const attrs = extractOtlpAttributes(raw);
-		const projected = {};
-		for (const [k, v] of Object.entries(attrs)) if (typeof v === "string") {
-			const trunc = truncateForBudget(v, perAttrCap);
-			if (trunc !== v) counter.value += 1;
-			projected[k] = trunc;
-		} else if (Array.isArray(v) || v && typeof v === "object") {
-			const json = JSON.stringify(v);
-			const trunc = truncateForBudget(json, perAttrCap);
-			if (trunc !== json) {
-				counter.value += 1;
-				projected[k] = trunc;
-			} else projected[k] = v;
-		} else projected[k] = v;
-		return {
-			trace_id,
-			span_id: s.span_id,
-			parent_span_id: s.parent_span_id,
-			name: s.name,
-			kind: s.kind,
-			start_time: s.start_time,
-			end_time: s.end_time,
-			duration_ms: s.duration_ms,
-			status: s.status,
-			status_message: s.status_message,
-			service_name: s.service_name,
-			agent_name: s.agent_name,
-			model_name: s.model_name,
-			tool_name: s.tool_name,
-			attributes: projected
-		};
-	}
-	buildOversizedSummary(t, span_response_bytes_max) {
-		const counts = /* @__PURE__ */ new Map();
-		let errorCount = 0;
-		for (const s of t.spans) {
-			counts.set(s.name, (counts.get(s.name) ?? 0) + 1);
-			if (s.status === "ERROR") errorCount += 1;
-		}
-		const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20);
-		return {
-			span_count: t.span_count,
-			top_span_names: top,
-			span_response_bytes_max,
-			error_span_count: errorCount
-		};
-	}
-	async scanSpanForMatches(buf, trace_id, s, re, textBudget, recordCap, context) {
-		const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length).toString("utf8");
-		const records = [];
-		let hasMore = false;
-		let matchIndex = 0;
-		for (const match of re.matchAll(slice)) {
-			await scanCheckpoint(context?.signal, matchIndex++);
-			if (records.length >= recordCap) {
-				hasMore = true;
-				break;
-			}
-			const offset = match.index ?? 0;
-			const before = slice.slice(Math.max(0, offset - textBudget / 2), offset);
-			const after = slice.slice(offset + match[0].length, offset + match[0].length + Math.floor(textBudget / 2));
-			records.push({
-				trace_id,
-				span_id: s.span_id,
-				span_name: s.name,
-				span_kind: s.kind,
-				attribute_path: bestAttributePathForOffset(slice, offset) ?? "span.raw",
-				matched_text: truncateForBudget(match[0], textBudget),
-				context_before: truncateForBudget(before, textBudget),
-				context_after: truncateForBudget(after, textBudget),
-				match_offset: offset
-			});
-		}
-		return {
-			records,
-			hasMore
-		};
-	}
-};
-var OtlpFileTraceStore = class extends BufferedOtlpTraceStore {
-	path;
-	maxFileBytes;
-	constructor(opts) {
-		super(opts);
-		this.path = opts.path;
-		this.maxFileBytes = validateInteger(opts.maxFileBytes ?? 268435456, "maxFileBytes", 1);
-	}
-	/** Stat-then-read so an oversized file fails loud before allocating the
-	*  source buffer. Missing files remain distinct from malformed traces. */
-	async readBuffer(signal) {
-		signal?.throwIfAborted();
-		let stats;
-		try {
-			stats = await stat(this.path);
-		} catch (err) {
-			if (err?.code === "ENOENT") throw new TraceFileMissingError(this.path);
-			throw err;
-		}
-		if (stats.size > this.maxFileBytes) throw new TraceFileTooLargeError(this.path, stats.size, this.maxFileBytes);
-		signal?.throwIfAborted();
-		return readFile(this.path, { signal });
-	}
-	sourcePath() {
-		return this.path;
-	}
-};
-var OtlpBufferTraceStore = class extends BufferedOtlpTraceStore {
-	source;
-	constructor(source, opts) {
-		super(opts);
-		this.source = source;
-	}
-	async readBuffer(signal) {
-		signal?.throwIfAborted();
-		return this.source;
-	}
-	sourcePath() {
-		return "<memory>";
-	}
-};
-/** Build the bounded trace store directly from OpenInference JSONL text. */
-function otlpTextToTraceAnalysisStore(text, opts = {}) {
-	if (!text.trim()) throw new CaptureIntegrityError("OTLP trace text must not be empty");
-	return new OtlpBufferTraceStore(Buffer.from(text, "utf8"), opts);
-}
-function createOtlpBufferTraceStore(source, options = {}) {
-	return new OtlpBufferTraceStore(source, options);
-}
-/** A `"` at `idx` is a real JSON delimiter only when the run of `\`
-*  immediately preceding it is even-length; an odd run means the quote
-*  is escaped (`\"`) and is part of a string value, not a boundary. */
-function isUnescapedQuote(slice, idx) {
-	if (slice[idx] !== "\"") return false;
-	let backslashes = 0;
-	let b = idx - 1;
-	while (b >= 0 && slice[b] === "\\") {
-		backslashes += 1;
-		b -= 1;
-	}
-	return backslashes % 2 === 0;
-}
-/** Scan backwards from `from` (inclusive) for the nearest UNescaped `"`.
-*  Returns its index, or -1 when none is found. */
-function prevUnescapedQuote(slice, from) {
-	for (let i = from; i >= 0; i -= 1) if (slice[i] === "\"" && isUnescapedQuote(slice, i)) return i;
-	return -1;
-}
-/**
-* Best-effort: locate the JSON path for the substring at `offset` in
-* a single span's JSONL slice. The slice is '...,"key":"value..."' — we
-* walk back from `offset` to the value-opening quote, past the `:`, to
-* the key's closing then opening quote, skipping `\"`-escaped quotes that
-* live inside string values. Returns `null` when the offset doesn't fall
-* inside a recognisable string field.
-*/
-function bestAttributePathForOffset(slice, offset) {
-	const valueQuote = prevUnescapedQuote(slice, Math.min(offset, slice.length - 1));
-	if (valueQuote < 1) return null;
-	let j = valueQuote - 1;
-	while (j >= 0 && slice[j] !== ":") j -= 1;
-	if (j < 1) return null;
-	const keyClose = prevUnescapedQuote(slice, j - 1);
-	if (keyClose < 1) return null;
-	const keyOpen = prevUnescapedQuote(slice, keyClose - 1);
-	if (keyOpen < 0) return null;
-	return slice.slice(keyOpen + 1, keyClose);
-}
-const ERROR_CLUSTER_EXEMPLARS = 5;
-/** Collapse volatile tokens so semantically identical failures share a key:
-*  hex/uuid ids → <id>, numbers → #, quoted/abs paths → <path>, durations →
-*  <dur>, whitespace collapsed. Empty/absent messages fall back to the span
-*  name so a no-message error still forms a real cluster. */
-function normalizeErrorSignature(message, spanName) {
-	const raw = (message ?? "").trim();
-	return (raw.length > 0 ? raw : `(${spanName || "error"} — no message)`).replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<id>").replace(/\b[0-9a-f]{12,}\b/gi, "<id>").replace(/(?:\/[\w.\-@]+){2,}/g, "<path>").replace(/\b\d+(?:\.\d+)?(ms|s|m|h|kb|mb|gb)?\b/gi, (_m, u) => u ? `#${u}` : "#").replace(/\s+/g, " ").trim();
-}
-function bump(map, key) {
-	if (!key) return;
-	map.set(key, (map.get(key) ?? 0) + 1);
-}
-function topKey(map) {
-	let best = null;
-	let bestN = 0;
-	for (const [k, n] of map) if (n > bestN) {
-		best = k;
-		bestN = n;
-	}
-	return best;
-}
-function accumulateErrorCluster(clusters, traceId, span) {
-	const signature = normalizeErrorSignature(span.status_message, span.name);
-	let acc = clusters.get(signature);
-	if (!acc) {
-		acc = {
-			signature,
-			sample: span.status_message ?? span.name ?? "",
-			traceIds: /* @__PURE__ */ new Set(),
-			spanIds: [],
-			spanCount: 0,
-			spanNames: /* @__PURE__ */ new Map(),
-			toolNames: /* @__PURE__ */ new Map()
-		};
-		clusters.set(signature, acc);
-	}
-	acc.traceIds.add(traceId);
-	acc.spanCount += 1;
-	if (acc.spanIds.length < ERROR_CLUSTER_EXEMPLARS && !acc.spanIds.includes(span.span_id)) acc.spanIds.push(span.span_id);
-	bump(acc.spanNames, span.name);
-	bump(acc.toolNames, span.tool_name);
-}
-function finalizeErrorClusters(clusters, errorTraceCount) {
-	const out = [...clusters.values()].map((acc) => ({
-		signature: acc.signature,
-		status_message_sample: acc.sample,
-		span_name: topKey(acc.spanNames),
-		tool_name: topKey(acc.toolNames),
-		trace_count: acc.traceIds.size,
-		span_count: acc.spanCount,
-		prevalence: errorTraceCount > 0 ? acc.traceIds.size / errorTraceCount : 0,
-		exemplar_trace_ids: [...acc.traceIds].slice(0, ERROR_CLUSTER_EXEMPLARS),
-		exemplar_span_ids: acc.spanIds.slice(0, ERROR_CLUSTER_EXEMPLARS)
-	}));
-	out.sort((a, b) => b.trace_count - a.trace_count || b.span_count - a.span_count);
-	return out;
-}
-const TRACE_ANALYSIS_COMPLETION_INSTRUCTION = `This host consumes your executor result directly; there is no downstream responder for this run. Ignore generic executor guidance that says a responder will format the answer. You must produce the final report and findings yourself.
-
-Return exactly one executable JavaScript program per turn. Never emit multiple JavaScript or code fences; put every tool call and the final call in that one program.
-
-When the analysis is complete, call \`await final(${JSON.stringify("Submit the completed trace analysis.")}, { report, findings })\` exactly once. Do not return a one-argument string from \`final(...)\`.`;
-var TraceAnalysisTurnLimitError = class extends Error {
-	analystId;
-	maxTurns;
-	constructor(analystId, maxTurns, cause) {
-		super(`Trace analyst '${analystId}' reached maxTurns=${maxTurns} without a structured final result`, { cause });
-		this.name = "TraceAnalysisTurnLimitError";
-		this.analystId = analystId;
-		this.maxTurns = maxTurns;
-	}
-};
-async function runTraceAnalysisLoop(options) {
-	validateLoopLimits(options);
-	const config = {
-		agentIdentity: {
-			name: options.id,
-			description: options.description
-		},
-		contextFields: [],
-		runtime: new AxJSRuntime({
-			permissions: [],
-			blockDynamicImport: true,
-			allowedModules: [],
-			freezeIntrinsics: true,
-			blockShadowRealm: true,
-			preventGlobalThisExtensions: false
-		}),
-		maxSubAgentCalls: options.maxSubqueries,
-		maxTurns: options.maxTurns,
-		maxRuntimeChars: options.maxRuntimeChars,
-		maxBatchedLlmQueryConcurrency: options.maxParallelSubqueries,
-		promptLevel: "detailed",
-		contextPolicy: {
-			preset: "full",
-			budget: "balanced"
-		},
-		functions: options.tools,
-		executorOptions: {
-			description: `${options.prompt.trim()}\n\n${TRACE_ANALYSIS_COMPLETION_INSTRUCTION}`,
-			...options.model ? { model: options.model } : {},
-			showThoughts: false,
-			thinkingTokenBudget: "none"
-		},
-		...options.onTurn ? { actorTurnCallback: options.onTurn } : {},
-		bubbleErrors: [TraceFileMissingError]
-	};
-	const analyst = options.findingType === "string" ? agent("question:string -> report:string, findings:string[]", config) : agent("question:string -> report:string, findings:json[]", config);
-	const state = await analyst.executor.run(options.ai, { question: options.question }, options.signal ? { abortSignal: options.signal } : void 0);
-	let completed;
-	try {
-		completed = options.findingType === "string" ? readTraceAnalysisCompletion(state.executorResult, "string") : readTraceAnalysisCompletion(state.executorResult, "object");
-	} catch (error) {
-		if (state.turnCount >= options.maxTurns) throw new TraceAnalysisTurnLimitError(options.id, options.maxTurns, error);
-		throw new Error(`Trace analyst '${options.id}' stopped without a structured final result`, { cause: error });
-	}
-	return {
-		...completed,
-		usage: analyst.executor.getUsage(),
-		chatLog: analyst.executor.getChatLog(),
-		turnCount: state.turnCount
-	};
-}
-function readTraceAnalysisCompletion(value, findingType) {
-	if (!value || typeof value !== "object") throw new Error("Trace analyst did not return a structured final result");
-	const completion = value;
-	if (completion.type !== "final" || !Array.isArray(completion.args) || completion.args.length !== 2 || completion.args[0] !== "Submit the completed trace analysis.") throw new Error("Trace analyst did not return a structured final result");
-	const payload = completion.args[1];
-	if (!payload || typeof payload !== "object") throw new Error("Trace analyst final result must contain report and findings");
-	const { report, findings } = payload;
-	if (typeof report !== "string" || !Array.isArray(findings)) throw new Error("Trace analyst final result must contain report and findings");
-	if (findingType === "string") {
-		if (findings.some((finding) => typeof finding !== "string")) throw new Error("Trace analyst final result must contain string findings");
-		return {
-			report,
-			findings
-		};
-	}
-	if (findings.some((finding) => !finding || typeof finding !== "object" || Array.isArray(finding))) throw new Error("Trace analyst final result must contain object findings");
-	return {
-		report,
-		findings
-	};
-}
-function validateLoopLimits(options) {
-	if (!Number.isSafeInteger(options.maxSubqueries) || options.maxSubqueries < 0) throw new TypeError("maxSubqueries must be a non-negative integer");
-	if (!Number.isSafeInteger(options.maxParallelSubqueries) || options.maxParallelSubqueries < 1) throw new TypeError("maxParallelSubqueries must be a positive integer");
-}
-//#endregion
-//#region src/trace-analyst/tools.ts
-const TRACE_ANALYST_TOOL_NAMESPACE = "traces";
-/** Bind all seven trace reads without exposing an agent framework type. */
-function buildTraceAnalysisToolDescriptors(options) {
-	const store = createBoundedTraceAnalysisStore(options.store, { budgets: options.budgets });
-	return [
-		{
-			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-			name: "getDatasetOverview",
-			description: "Dataset rollup: total traces, raw_jsonl_bytes, services, agents, models, tools, and sample_trace_ids. Always call this first without a regex_pattern.",
-			parameters: toTraceJsonSchema(traceStoreInputSchemas.getOverview),
-			handler: async (args, context) => {
-				const { filters } = parseTraceInput("getDatasetOverview", traceStoreInputSchemas.getOverview, args ?? {});
-				return store.getOverview(filters, context);
-			}
-		},
-		{
-			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-			name: "queryTraces",
-			description: `Paginated trace summaries, at most ${TRACE_ANALYSIS_LIMITS.queryTraces} per call. Each summary carries raw_jsonl_bytes; narrow with indexed filters before regex_pattern.`,
-			parameters: toTraceJsonSchema(traceStoreInputSchemas.queryTraces),
-			handler: async (args, context) => {
-				const input = parseTraceInput("queryTraces", traceStoreInputSchemas.queryTraces, args);
-				return store.queryTraces(input, context);
-			}
-		},
-		{
-			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-			name: "countTraces",
-			description: "Count traces matching filters. Use as a cheap pre-flight before a regex_pattern scan.",
-			parameters: toTraceJsonSchema(traceStoreInputSchemas.countTraces),
-			handler: async (args, context) => {
-				const { filters } = parseTraceInput("countTraces", traceStoreInputSchemas.countTraces, args ?? {});
-				return store.countTraces(filters, context);
-			}
-		},
-		{
-			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-			name: "viewTrace",
-			description: "Return all spans for one trace with bounded attributes. Oversized responses carry an oversized summary instead of spans; continue with searchTrace or viewSpans.",
-			parameters: toTraceJsonSchema(traceStoreInputSchemas.viewTrace.omit({ per_attribute_byte_cap: true })),
-			handler: async (args, context) => {
-				const input = parseTraceInput("viewTrace", traceStoreInputSchemas.viewTrace.omit({ per_attribute_byte_cap: true }), args);
-				return store.viewTrace(input, context);
-			}
-		},
-		{
-			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-			name: "viewSpans",
-			description: `Read 1..${TRACE_ANALYSIS_LIMITS.viewSpans} specific spans. Every requested id is accounted for in spans, missing_span_ids, or omitted_span_ids; retry omitted ids.`,
-			parameters: toTraceJsonSchema(traceStoreInputSchemas.viewSpans.omit({ per_attribute_byte_cap: true })),
-			handler: async (args, context) => {
-				const input = parseTraceInput("viewSpans", traceStoreInputSchemas.viewSpans.omit({ per_attribute_byte_cap: true }), args);
-				return store.viewSpans(input, context);
-			}
-		},
-		{
-			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-			name: "searchTrace",
-			description: `Regex search across one trace, bounded to ${TRACE_ANALYSIS_LIMITS.searchMatches} hits. When has_more is true, refine the regex instead of treating the result as complete.`,
-			parameters: toTraceJsonSchema(traceStoreInputSchemas.searchTrace),
-			handler: async (args, context) => {
-				const input = parseTraceInput("searchTrace", traceStoreInputSchemas.searchTrace, args);
-				return store.searchTrace(input, context);
-			}
-		},
-		{
-			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-			name: "searchSpan",
-			description: `Regex search inside one span, bounded to ${TRACE_ANALYSIS_LIMITS.searchMatches} hits. Use after viewSpans omits or truncates a large span payload.`,
-			parameters: toTraceJsonSchema(traceStoreInputSchemas.searchSpan),
-			handler: async (args, context) => {
-				const input = parseTraceInput("searchSpan", traceStoreInputSchemas.searchSpan, args);
-				return store.searchSpan(input, context);
-			}
-		}
-	];
-}
-/** Adapt the canonical descriptors into Ax functions used by the built-in analyst. */
-function buildTraceAnalystTools(options) {
-	return buildTraceAnalysisToolDescriptors(options).map((descriptor) => ({
-		namespace: descriptor.namespace,
-		name: descriptor.name,
-		description: descriptor.description,
-		parameters: descriptor.parameters,
-		func: (args, extra) => descriptor.handler(args, extra?.abortSignal ? { signal: extra.abortSignal } : void 0)
-	}));
-}
-function traceAnalystFunctionGroup(options) {
-	return {
-		namespace: TRACE_ANALYST_TOOL_NAMESPACE,
-		title: "Trace Analysis",
-		selectionCriteria: "Use for any inspection of OTLP-shaped trace data.",
-		description: "Discovery, narrowing, and bounded deep reads over a JSONL trace dataset. Always call getDatasetOverview first.",
-		functions: buildTraceAnalystTools(options)
-	};
-}
-//#endregion
-export { applyToolSpanOtlpAttributes as A, extractOtlpAttributes as C, readOtlpStatus as D, projectOtlpFlatLine as E, isOtlpModelCall as M, traceSpanKindToOpenInferenceKind as N, spanEpochMillis as O, compareSpanTime as S, inferOtlpKind as T, TraceFileMalformedError as _, runTraceAnalysisLoop as a, TraceNotFoundError as b, otlpTextToTraceAnalysisStore as c, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as d, TRACE_ANALYSIS_LIMITS as f, TraceAnalysisValidationError as g, TraceAnalysisStoreContractError as h, traceAnalystFunctionGroup as i, classifyOtlpSpanRole as j, stringField as k, createBoundedTraceAnalysisStore as l, TraceAnalysisLimitError as m, buildTraceAnalysisToolDescriptors as n, OtlpFileTraceStore as o, SpanNotFoundError as p, buildTraceAnalystTools as r, createOtlpBufferTraceStore as s, TRACE_ANALYST_TOOL_NAMESPACE as t, DEFAULT_TRACE_ANALYST_BUDGETS as u, TraceFileMissingError as v, firstStringAttr as w, asString as x, TraceFileTooLargeError as y };
-
-//# sourceMappingURL=tools-DZk2Jn64.js.map