promptfoo 0.125.0 → 0.125.1

package/dist/src/traceContext-Brw3Oe41.js

@@ -0,0 +1,1016 @@
+#!/usr/bin/env node
+import { c as logger } from "./logger-pCNnmVuz.js";
+import { r as fetchWithProxy } from "./fetch-RXHsZF-J.js";
+import { Rt as hasTraceCredentialPath } from "./tables-BONxKPrt.js";
+import { c as getToolNameFromAttributes, l as sanitizeTraceAttributes, n as getTraceStore, s as getNormalizedToolAttributes } from "./store-DFoDZ_D2.js";
+//#region src/tracing/providers/types.ts
+var TraceProviderError = class extends Error {
+	statusCode;
+	retryable;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "TraceProviderError";
+		this.statusCode = options.statusCode;
+		this.retryable = options.retryable ?? false;
+	}
+};
+//#endregion
+//#region src/tracing/providers/fetch.ts
+const MAX_TRACE_RESPONSE_BYTES = 10485760;
+function validateTraceProviderEndpoint(endpoint, providerName) {
+	let url;
+	try {
+		url = new URL(endpoint);
+	} catch {
+		throw new Error(`${providerName} provider endpoint must be a valid HTTP or HTTPS URL`);
+	}
+	const hasCredentialPath = hasTraceCredentialPath(url.pathname);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || hasCredentialPath) throw new Error(`${providerName} provider endpoint must be an HTTP or HTTPS URL without credentials, query parameters, or fragments`);
+}
+async function releaseResponse(response, providerName) {
+	try {
+		await response.body?.cancel();
+	} catch (error) {
+		logger.debug(`[${providerName}Provider] Failed to release response body: ${error}`);
+	}
+}
+async function readLimitedResponse(response, providerName, maxResponseBytes = MAX_TRACE_RESPONSE_BYTES) {
+	const reader = response.body?.getReader();
+	if (!reader) return "";
+	const decoder = new TextDecoder();
+	let byteLength = 0;
+	let body = "";
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) return body + decoder.decode();
+		byteLength += value.byteLength;
+		if (byteLength > maxResponseBytes) {
+			await reader.cancel();
+			throw new TraceProviderError(`${providerName} trace exceeds the maximum response size`);
+		}
+		body += decoder.decode(value, { stream: true });
+	}
+}
+//#endregion
+//#region src/tracing/providers/braintrust.ts
+const MAX_SPANS$2 = 1e4;
+const TRACE_ID_PATTERN$2 = /^[0-9a-f]{32}$/i;
+const PROJECT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function timestampMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value < 1e10 ? Math.round(value * 1e3) : Math.round(value);
+	if (typeof value === "string") {
+		const parsed = Date.parse(value);
+		return Number.isNaN(parsed) ? void 0 : parsed;
+	}
+}
+function transformSpan$1(row, options) {
+	const spanId = row.span_id || row.id;
+	const startTime = timestampMs(row.metrics?.start) ?? timestampMs(row.created);
+	if (!spanId || startTime === void 0) return null;
+	if (options?.earliestStartTime !== void 0 && startTime < options.earliestStartTime) return null;
+	const parentSpanId = row.span_parents?.slice().reverse().find((parent) => parent && parent !== spanId);
+	const name = typeof row.span_attributes?.name === "string" ? row.span_attributes.name : "braintrust.span";
+	const isToolSpan = row.span_attributes?.type === "tool";
+	const attributes = {
+		...row.metadata,
+		...row.span_attributes,
+		...row.metrics && { "braintrust.metrics": row.metrics },
+		...row.input !== void 0 && { "braintrust.input": row.input },
+		...row.output !== void 0 && { "braintrust.output": row.output },
+		...typeof row.span_attributes?.type === "string" && { "braintrust.span.type": row.span_attributes.type },
+		...isToolSpan && getNormalizedToolAttributes(name, row.input)
+	};
+	return {
+		spanId,
+		...parentSpanId && { parentSpanId },
+		name,
+		startTime,
+		...timestampMs(row.metrics?.end) !== void 0 && { endTime: timestampMs(row.metrics?.end) },
+		attributes,
+		statusCode: row.error ? 2 : 1,
+		...row.error ? { statusMessage: String(row.error) } : {}
+	};
+}
+/** Retrieve Braintrust project traces correlated with an OpenTelemetry trace ID. */
+var BraintrustProvider = class {
+	config;
+	id = "braintrust";
+	baseUrl;
+	projectId;
+	token;
+	constructor(config) {
+		this.config = config;
+		if (!config.endpoint) throw new Error("Braintrust provider requires endpoint configuration");
+		if (!config.projectId || !PROJECT_ID_PATTERN.test(config.projectId)) throw new Error("Braintrust provider requires a valid projectId");
+		if (!config.auth?.token) throw new Error("Braintrust provider requires an auth token");
+		validateTraceProviderEndpoint(config.endpoint, "Braintrust");
+		if (config.timeout !== void 0 && (!Number.isSafeInteger(config.timeout) || config.timeout <= 0)) throw new Error("Braintrust provider timeout must be a positive integer");
+		this.baseUrl = config.endpoint.replace(/\/$/, "");
+		this.projectId = config.projectId;
+		this.token = config.auth.token;
+	}
+	buildHeaders() {
+		const headers = { ...this.config.headers };
+		for (const header of Object.keys(headers)) if ([
+			"accept",
+			"authorization",
+			"content-type"
+		].includes(header.toLowerCase())) delete headers[header];
+		return {
+			...headers,
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${this.token}`
+		};
+	}
+	async fetchTrace(traceId, options) {
+		if (!TRACE_ID_PATTERN$2.test(traceId) || /^0+$/.test(traceId)) throw new TraceProviderError("Trace ID must contain 32 hexadecimal characters");
+		const normalizedTraceId = traceId.toLowerCase();
+		const maxSpans = Math.min(options?.maxSpans ?? MAX_SPANS$2, MAX_SPANS$2);
+		const query = [
+			"SELECT id, span_id, root_span_id, span_parents, created, input, output,",
+			"  error, metadata, metrics, span_attributes",
+			`FROM project_logs('${this.projectId}', shape => 'traces')`,
+			"WHERE created >= now() - INTERVAL 1 DAY",
+			`  AND (metadata.trace_id = '${normalizedTraceId}'`,
+			`    OR metadata.promptfoo_trace_id = '${normalizedTraceId}'`,
+			`    OR metadata."promptfoo.trace_id" = '${normalizedTraceId}'`,
+			`    OR root_span_id = '${normalizedTraceId}')`,
+			`LIMIT ${maxSpans}`
+		].join("\n");
+		const timeoutSignal = AbortSignal.timeout(this.config.timeout ?? 1e4);
+		const signal = options?.abortSignal ? AbortSignal.any([timeoutSignal, options.abortSignal]) : timeoutSignal;
+		const response = await fetchWithProxy(`${this.baseUrl}/btql`, {
+			disableTransientRetries: true,
+			method: "POST",
+			headers: this.buildHeaders(),
+			body: JSON.stringify({
+				query,
+				fmt: "json"
+			}),
+			redirect: "error",
+			signal
+		});
+		if (response.status === 404) {
+			await releaseResponse(response, "Braintrust");
+			throw new TraceProviderError("Braintrust BTQL endpoint returned HTTP 404; check the endpoint and project configuration", { statusCode: response.status });
+		}
+		if (!response.ok) {
+			await releaseResponse(response, "Braintrust");
+			throw new TraceProviderError(`Braintrust returned HTTP ${response.status}`, {
+				statusCode: response.status,
+				retryable: response.status === 408 || response.status === 429 || response.status >= 500
+			});
+		}
+		if (Number(response.headers.get("content-length")) > 10485760) {
+			await releaseResponse(response, "Braintrust");
+			throw new TraceProviderError("Braintrust trace exceeds the maximum response size");
+		}
+		const body = await readLimitedResponse(response, "Braintrust");
+		const result = JSON.parse(body);
+		const rows = result.rows ?? result.data;
+		if (!Array.isArray(rows)) throw new TraceProviderError("Braintrust returned an invalid query response");
+		if (rows.length === 0) return null;
+		const spans = [];
+		for (const row of rows) {
+			if (spans.length >= maxSpans) break;
+			const span = transformSpan$1(row, options);
+			if (!span) {
+				logger.warn("[BraintrustProvider] Skipping malformed span");
+				continue;
+			}
+			spans.push(span);
+		}
+		return spans.length > 0 ? {
+			spans,
+			fetchedAt: Date.now()
+		} : null;
+	}
+};
+//#endregion
+//#region src/tracing/providers/langfuse.ts
+const MAX_SPANS$1 = 1e4;
+const MAX_PAGE_SIZE = 1e3;
+const TRACE_ID_PATTERN$1 = /^[0-9a-f]{32}$/i;
+const RESERVED_ATTRIBUTE_KEY_SEGMENTS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const GEN_AI_OPERATION_NAMES = {
+	AGENT: "invoke_agent",
+	CHAIN: "invoke_workflow",
+	EMBEDDING: "embeddings",
+	GENERATION: "chat",
+	RETRIEVER: "retrieval",
+	TOOL: "execute_tool"
+};
+const GEN_AI_MODEL_PARAMETER_NAMES = {
+	frequency_penalty: "gen_ai.request.frequency_penalty",
+	frequencyPenalty: "gen_ai.request.frequency_penalty",
+	max_tokens: "gen_ai.request.max_tokens",
+	maxTokens: "gen_ai.request.max_tokens",
+	presence_penalty: "gen_ai.request.presence_penalty",
+	presencePenalty: "gen_ai.request.presence_penalty",
+	seed: "gen_ai.request.seed",
+	temperature: "gen_ai.request.temperature",
+	top_k: "gen_ai.request.top_k",
+	top_p: "gen_ai.request.top_p",
+	topK: "gen_ai.request.top_k",
+	topP: "gen_ai.request.top_p"
+};
+function parseJsonValue(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function safeAttributes(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return Object.fromEntries(Object.entries(value).filter(([key]) => !key.split(".").some((segment) => RESERVED_ATTRIBUTE_KEY_SEGMENTS.has(segment))));
+}
+function firstNumericValue(...values) {
+	return values.find((value) => typeof value === "number" && Number.isFinite(value));
+}
+function normalizedModelParameters(value) {
+	const attributes = {};
+	for (const [name, parameter] of Object.entries(safeAttributes(value))) if (Object.prototype.hasOwnProperty.call(GEN_AI_MODEL_PARAMETER_NAMES, name) && typeof parameter === "number" && Number.isFinite(parameter)) attributes[GEN_AI_MODEL_PARAMETER_NAMES[name]] = parameter;
+	return attributes;
+}
+function observationOperationName(observation, attributes) {
+	const originalOperation = attributes["gen_ai.operation.name"];
+	if (typeof originalOperation === "string" && originalOperation.trim()) return originalOperation;
+	if (typeof observation.type !== "string") return;
+	if (observation.type === "GENERATION" && typeof observation.name === "string") {
+		const normalizedName = observation.name.trim().toLowerCase();
+		if (/^text[ _-]completion(?:\b|$)/.test(normalizedName)) return "text_completion";
+		if (/^generate[ _-]content(?:\b|$)/.test(normalizedName)) return "generate_content";
+	}
+	return GEN_AI_OPERATION_NAMES[observation.type];
+}
+function observationAttributes(observation) {
+	const metadata = safeAttributes(observation.metadata);
+	const resourceAttributes = safeAttributes(metadata.resourceAttributes);
+	const telemetryAttributes = safeAttributes(metadata.attributes);
+	const usageDetails = safeAttributes(observation.usageDetails);
+	const costDetails = safeAttributes(observation.costDetails);
+	const inputCost = costDetails.input ?? observation.calculatedInputCost ?? observation.inputCost;
+	const outputCost = costDetails.output ?? observation.calculatedOutputCost ?? observation.outputCost;
+	const totalCost = costDetails.total ?? observation.calculatedTotalCost ?? observation.totalCost;
+	const inputTokens = firstNumericValue(observation.inputUsage, usageDetails.input, usageDetails.input_tokens, usageDetails.prompt_tokens);
+	const outputTokens = firstNumericValue(observation.outputUsage, usageDetails.output, usageDetails.output_tokens, usageDetails.completion_tokens);
+	const totalTokens = firstNumericValue(observation.totalUsage, usageDetails.total, usageDetails.total_tokens);
+	const reasoningTokens = firstNumericValue(usageDetails.reasoning, usageDetails.reasoning_tokens);
+	const cacheReadTokens = firstNumericValue(usageDetails.cache_read_input_tokens, usageDetails.cached_tokens);
+	const cacheCreationTokens = firstNumericValue(usageDetails.cache_creation_input_tokens);
+	const operationName = observationOperationName(observation, {
+		...metadata,
+		...telemetryAttributes
+	});
+	const parsedInput = parseJsonValue(observation.input);
+	const parsedOutput = parseJsonValue(observation.output);
+	const observationName = typeof observation.name === "string" && observation.name.trim() ? observation.name : void 0;
+	return {
+		...resourceAttributes,
+		...metadata,
+		...normalizedModelParameters(observation.modelParameters),
+		...operationName && { "gen_ai.operation.name": operationName },
+		...typeof observation.type === "string" && { "langfuse.observation.type": observation.type },
+		...observation.input !== void 0 && { "langfuse.input": parsedInput },
+		...observation.type === "TOOL" && observationName && {
+			...getNormalizedToolAttributes(observationName, parsedInput),
+			...observation.input !== void 0 && { "gen_ai.tool.call.arguments": parsedInput },
+			...observation.output !== void 0 && { "gen_ai.tool.call.result": parsedOutput }
+		},
+		...observation.type === "AGENT" && observationName && { "gen_ai.agent.name": observationName },
+		...observation.type === "CHAIN" && observationName && { "gen_ai.workflow.name": observationName },
+		...observation.type === "EVALUATOR" && observationName && { "gen_ai.evaluation.name": observationName },
+		...observation.type === "GUARDRAIL" && observationName && { "guardrail.name": observationName },
+		...observation.output !== void 0 && { "langfuse.output": parsedOutput },
+		...typeof observation.providedModelName === "string" && { "gen_ai.request.model": observation.providedModelName },
+		...observation.modelParameters !== void 0 && observation.modelParameters !== null && { "langfuse.model.parameters": observation.modelParameters },
+		...observation.usageDetails !== void 0 && observation.usageDetails !== null && { "langfuse.usage": observation.usageDetails },
+		...inputTokens !== void 0 && { "gen_ai.usage.input_tokens": inputTokens },
+		...outputTokens !== void 0 && { "gen_ai.usage.output_tokens": outputTokens },
+		...totalTokens !== void 0 && {
+			"langfuse.usage.total_tokens": totalTokens,
+			"promptfoo.usage.total_tokens": totalTokens
+		},
+		...reasoningTokens !== void 0 && { "gen_ai.usage.reasoning.output_tokens": reasoningTokens },
+		...cacheReadTokens !== void 0 && { "gen_ai.usage.cache_read.input_tokens": cacheReadTokens },
+		...cacheCreationTokens !== void 0 && { "gen_ai.usage.cache_creation.input_tokens": cacheCreationTokens },
+		...typeof inputCost === "number" && { "langfuse.cost.input": inputCost },
+		...typeof outputCost === "number" && { "langfuse.cost.output": outputCost },
+		...typeof totalCost === "number" && { "langfuse.cost.total": totalCost },
+		...telemetryAttributes
+	};
+}
+function transformObservation(observation, traceId, options) {
+	if (typeof observation.id !== "string" || !observation.id || typeof observation.traceId !== "string" || observation.traceId.toLowerCase() !== traceId || typeof observation.startTime !== "string") return null;
+	const startTime = Date.parse(observation.startTime);
+	if (Number.isNaN(startTime) || options?.earliestStartTime !== void 0 && startTime < options.earliestStartTime) return null;
+	const endTime = typeof observation.endTime === "string" ? Date.parse(observation.endTime) : NaN;
+	if (observation.endTime != null && (Number.isNaN(endTime) || endTime < startTime)) return null;
+	if (observation.parentObservationId != null && (typeof observation.parentObservationId !== "string" || !observation.parentObservationId || observation.parentObservationId === observation.id)) return null;
+	return {
+		spanId: observation.id,
+		...typeof observation.parentObservationId === "string" && { parentSpanId: observation.parentObservationId },
+		name: typeof observation.name === "string" && observation.name.trim() ? observation.name : "langfuse.observation",
+		startTime,
+		...Number.isFinite(endTime) && { endTime },
+		attributes: observationAttributes(observation),
+		statusCode: observation.level === "ERROR" ? 2 : 1,
+		...typeof observation.statusMessage === "string" && observation.statusMessage && { statusMessage: observation.statusMessage }
+	};
+}
+function addObservations(observations, spans, seenSpanIds, traceId, maxSpans, options) {
+	for (const observation of observations) {
+		if (!observation || typeof observation !== "object" || Array.isArray(observation)) {
+			logger.warn("[LangfuseProvider] Skipping malformed observation");
+			continue;
+		}
+		const span = transformObservation(observation, traceId, options);
+		if (!span) {
+			logger.warn("[LangfuseProvider] Skipping malformed or unrelated observation");
+			continue;
+		}
+		if (!seenSpanIds.has(span.spanId)) {
+			seenSpanIds.add(span.spanId);
+			spans.push(span);
+		}
+		if (spans.length >= maxSpans) return;
+	}
+}
+function getNextCursor(response, seenCursors) {
+	const cursor = response.meta?.cursor;
+	if (cursor == null) return;
+	if (typeof cursor !== "string" || !cursor) throw new TraceProviderError("Langfuse returned an invalid pagination cursor");
+	if (seenCursors.has(cursor)) throw new TraceProviderError("Langfuse returned a repeated pagination cursor");
+	seenCursors.add(cursor);
+	return cursor;
+}
+function getNextPage(response) {
+	const { page, totalPages } = response.meta ?? {};
+	if (page == null && totalPages == null) return;
+	if (page === 1 && totalPages === 0 && Array.isArray(response.data) && response.data.length === 0) return;
+	if (typeof page !== "number" || !Number.isSafeInteger(page) || page < 1 || typeof totalPages !== "number" || !Number.isSafeInteger(totalPages) || totalPages < page) throw new TraceProviderError("Langfuse returned invalid pagination metadata");
+	return page < totalPages ? page + 1 : void 0;
+}
+/** Retrieve trace observations from Langfuse's public v2 Observations API. */
+var LangfuseProvider = class {
+	config;
+	id = "langfuse";
+	baseUrl;
+	authorization;
+	constructor(config) {
+		this.config = config;
+		if (!config.endpoint) throw new Error("Langfuse provider requires endpoint configuration");
+		if (!config.auth?.username || !config.auth.password || config.auth.token) throw new Error("Langfuse provider requires public and secret keys as basic-auth credentials");
+		validateTraceProviderEndpoint(config.endpoint, "Langfuse");
+		if (config.timeout !== void 0 && (!Number.isSafeInteger(config.timeout) || config.timeout <= 0)) throw new Error("Langfuse provider timeout must be a positive integer");
+		this.baseUrl = config.endpoint.replace(/\/$/, "");
+		this.authorization = `Basic ${Buffer.from(`${config.auth.username}:${config.auth.password}`).toString("base64")}`;
+	}
+	buildHeaders() {
+		return {
+			...Object.fromEntries(Object.entries(this.config.headers ?? {}).filter(([name]) => !["accept", "authorization"].includes(name.toLowerCase()))),
+			Accept: "application/json",
+			Authorization: this.authorization
+		};
+	}
+	async fetchTrace(traceId, options) {
+		if (!TRACE_ID_PATTERN$1.test(traceId) || /^0+$/.test(traceId)) throw new TraceProviderError("Trace ID must contain 32 hexadecimal characters");
+		const normalizedTraceId = traceId.toLowerCase();
+		const maxSpans = Math.min(Math.max(options?.maxSpans ?? MAX_SPANS$1, 1), MAX_SPANS$1);
+		const pageSize = Math.min(maxSpans, MAX_PAGE_SIZE);
+		const timeoutSignal = AbortSignal.timeout(this.config.timeout ?? 1e4);
+		const signal = options?.abortSignal ? AbortSignal.any([timeoutSignal, options.abortSignal]) : timeoutSignal;
+		const spans = [];
+		const seenSpanIds = /* @__PURE__ */ new Set();
+		const seenCursors = /* @__PURE__ */ new Set();
+		let page;
+		let cursor;
+		let remainingBytes = MAX_TRACE_RESPONSE_BYTES;
+		do {
+			const url = new URL(`${this.baseUrl}/api/public/v2/observations`);
+			url.searchParams.set("traceId", normalizedTraceId);
+			url.searchParams.set("fields", "core,basic,io,metadata,model,usage");
+			url.searchParams.set("limit", String(pageSize));
+			if (options?.earliestStartTime !== void 0) url.searchParams.set("fromStartTime", new Date(options.earliestStartTime).toISOString());
+			if (cursor) url.searchParams.set("cursor", cursor);
+			if (page) url.searchParams.set("page", String(page));
+			const response = await fetchWithProxy(url.toString(), {
+				disableTransientRetries: true,
+				method: "GET",
+				headers: this.buildHeaders(),
+				redirect: "error",
+				signal
+			});
+			if (response.status === 404) {
+				await releaseResponse(response, "Langfuse");
+				return null;
+			}
+			if (!response.ok) {
+				await releaseResponse(response, "Langfuse");
+				throw new TraceProviderError(`Langfuse returned HTTP ${response.status}`, {
+					statusCode: response.status,
+					retryable: response.status === 408 || response.status === 429 || response.status >= 500
+				});
+			}
+			if (Number(response.headers.get("content-length")) > remainingBytes) {
+				await releaseResponse(response, "Langfuse");
+				throw new TraceProviderError("Langfuse trace exceeds the maximum response size");
+			}
+			const body = await readLimitedResponse(response, "Langfuse", remainingBytes);
+			remainingBytes -= new TextEncoder().encode(body).byteLength;
+			const result = JSON.parse(body);
+			if (!Array.isArray(result.data)) throw new TraceProviderError("Langfuse returned an invalid observations response");
+			addObservations(result.data, spans, seenSpanIds, normalizedTraceId, maxSpans, options);
+			page = getNextPage(result);
+			cursor = page ? void 0 : getNextCursor(result, seenCursors);
+		} while ((page || cursor) && spans.length < maxSpans);
+		if (spans.length === 0) return null;
+		return {
+			spans,
+			fetchedAt: Date.now()
+		};
+	}
+};
+//#endregion
+//#region src/tracing/providers/tempo.ts
+const MAX_SPANS = 1e4;
+const SPAN_KIND_NAMES = [
+	"unspecified",
+	"internal",
+	"server",
+	"client",
+	"producer",
+	"consumer"
+];
+const TRACE_ID_PATTERN = /^[0-9a-f]{32}$/i;
+const BASE64_TRACE_ID_PATTERN = /^[A-Za-z0-9+/]{22}(?:==)?$/;
+const SPAN_ID_PATTERN = /^[0-9a-f]{16}$/i;
+const BASE64_SPAN_ID_PATTERN = /^[A-Za-z0-9+/]{11}=?$/;
+function nanoToMs(value) {
+	const milliseconds = BigInt(value) / 1000000n;
+	if (milliseconds < 0n || milliseconds > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("Span timestamp is outside the supported range");
+	return Number.parseInt(milliseconds.toString(), 10);
+}
+function extractAttributeValue(value) {
+	if (value.stringValue !== void 0) return value.stringValue;
+	if (value.intValue !== void 0) {
+		const number = Number(value.intValue);
+		return Number.isSafeInteger(number) ? number : value.intValue;
+	}
+	if (value.doubleValue !== void 0) return value.doubleValue;
+	if (value.boolValue !== void 0) return value.boolValue;
+	if (value.bytesValue !== void 0) return value.bytesValue;
+	if (value.arrayValue) return (value.arrayValue.values ?? []).map(extractAttributeValue);
+	if (value.kvlistValue) return attributesToRecord(value.kvlistValue.values);
+}
+function attributesToRecord(attributes) {
+	return Object.fromEntries((attributes ?? []).map(({ key, value }) => [key, extractAttributeValue(value)]));
+}
+function decodeId(id, hexPattern, base64Pattern, byteLength) {
+	if (!id) return;
+	if (hexPattern.test(id)) return /^0+$/.test(id) ? void 0 : id.toLowerCase();
+	if (!base64Pattern.test(id)) return;
+	const decoded = Buffer.from(id, "base64");
+	if (decoded.length !== byteLength || decoded.toString("base64").replace(/=+$/, "") !== id.replace(/=+$/, "")) return;
+	const hexId = decoded.toString("hex");
+	return /^0+$/.test(hexId) ? void 0 : hexId;
+}
+function normalizeStatusCode(code) {
+	if (typeof code === "number") return code;
+	if (!code) return;
+	const numeric = Number(code);
+	if (!Number.isNaN(numeric)) return numeric;
+	switch (code.toUpperCase()) {
+		case "STATUS_CODE_OK":
+		case "OK": return 1;
+		case "STATUS_CODE_ERROR":
+		case "ERROR": return 2;
+		case "STATUS_CODE_UNSET":
+		case "UNSET": return 0;
+		default: return;
+	}
+}
+function transformSpan(span, traceId, resourceAttributes, scopeName) {
+	if (decodeId(span.traceId, TRACE_ID_PATTERN, BASE64_TRACE_ID_PATTERN, 16) !== traceId.toLowerCase()) throw new Error("Span trace ID must match the requested trace");
+	const spanId = decodeId(span.spanId, SPAN_ID_PATTERN, BASE64_SPAN_ID_PATTERN, 8);
+	if (!spanId) throw new Error("Span ID must be a valid nonzero eight-byte identifier");
+	const parentSpanId = decodeId(span.parentSpanId, SPAN_ID_PATTERN, BASE64_SPAN_ID_PATTERN, 8);
+	if (span.parentSpanId && !parentSpanId) throw new Error("Parent span ID must be a valid nonzero eight-byte identifier");
+	if (typeof span.name !== "string" || span.name.trim().length === 0) throw new Error("Span name must be a nonempty string");
+	if (span.status?.message !== void 0 && typeof span.status.message !== "string") throw new Error("Span status message must be a string");
+	const startTime = nanoToMs(span.startTimeUnixNano);
+	const endTimeUnixNano = span.endTimeUnixNano;
+	const endTime = endTimeUnixNano ? nanoToMs(endTimeUnixNano) : void 0;
+	if (endTimeUnixNano && BigInt(endTimeUnixNano) < BigInt(span.startTimeUnixNano)) throw new Error("Span end time must not precede its start time");
+	return {
+		spanId,
+		parentSpanId,
+		name: span.name,
+		startTime,
+		endTime,
+		attributes: {
+			...resourceAttributes,
+			...attributesToRecord(span.attributes),
+			...scopeName && { "otel.scope.name": scopeName },
+			...typeof span.kind === "number" && {
+				"otel.span.kind": SPAN_KIND_NAMES[span.kind] ?? "unspecified",
+				"otel.span.kind_code": span.kind
+			},
+			...typeof span.kind === "string" && { "otel.span.kind": span.kind.replace(/^SPAN_KIND_/i, "").toLowerCase() }
+		},
+		statusCode: normalizeStatusCode(span.status?.code),
+		statusMessage: span.status?.message
+	};
+}
+var TempoProvider = class {
+	config;
+	id = "tempo";
+	baseUrl;
+	constructor(config) {
+		this.config = config;
+		if (!config.endpoint) throw new Error("Tempo provider requires endpoint configuration");
+		validateTraceProviderEndpoint(config.endpoint, "Tempo");
+		if (config.timeout !== void 0 && (!Number.isSafeInteger(config.timeout) || config.timeout <= 0)) throw new Error("Tempo provider timeout must be a positive integer");
+		this.baseUrl = config.endpoint.replace(/\/$/, "");
+	}
+	buildHeaders() {
+		const headers = { ...this.config.headers };
+		const hasConfiguredAuthentication = Boolean(this.config.auth?.token || this.config.auth?.username && this.config.auth?.password);
+		for (const header of Object.keys(headers)) {
+			const normalizedHeader = header.toLowerCase();
+			if (normalizedHeader === "accept" || hasConfiguredAuthentication && normalizedHeader === "authorization") delete headers[header];
+		}
+		headers.Accept = "application/json";
+		if (this.config.auth?.token) headers.Authorization = `Bearer ${this.config.auth.token}`;
+		else if (this.config.auth?.username && this.config.auth?.password) headers.Authorization = `Basic ${Buffer.from(`${this.config.auth.username}:${this.config.auth.password}`).toString("base64")}`;
+		return headers;
+	}
+	transformSpans(data, traceId) {
+		const spans = [];
+		const seenSpanIds = /* @__PURE__ */ new Set();
+		let malformedSpans = 0;
+		for (const batch of data.batches ?? []) {
+			if (!batch || !Array.isArray(batch.scopeSpans)) {
+				malformedSpans++;
+				continue;
+			}
+			const resourceAttributes = attributesToRecord(batch.resource?.attributes);
+			for (const scopeSpan of batch.scopeSpans) {
+				if (!scopeSpan || !Array.isArray(scopeSpan.spans)) {
+					malformedSpans++;
+					continue;
+				}
+				for (const span of scopeSpan.spans) {
+					if (spans.length >= MAX_SPANS) return spans;
+					try {
+						const normalizedSpan = transformSpan(span, traceId, resourceAttributes, scopeSpan.scope?.name);
+						if (normalizedSpan && !seenSpanIds.has(normalizedSpan.spanId)) {
+							seenSpanIds.add(normalizedSpan.spanId);
+							spans.push(normalizedSpan);
+						}
+					} catch {
+						malformedSpans++;
+					}
+				}
+			}
+		}
+		if (malformedSpans > 0) logger.warn(`[TempoProvider] Skipped ${malformedSpans} malformed spans`);
+		return spans;
+	}
+	async fetchTrace(traceId, options) {
+		if (!TRACE_ID_PATTERN.test(traceId) || /^0+$/.test(traceId)) throw new TraceProviderError("Trace ID must contain 32 hexadecimal characters");
+		const timeoutSignal = AbortSignal.timeout(this.config.timeout ?? 1e4);
+		const signal = options?.abortSignal ? AbortSignal.any([timeoutSignal, options.abortSignal]) : timeoutSignal;
+		const response = await fetchWithProxy(`${this.baseUrl}/api/traces/${traceId}`, {
+			disableTransientRetries: true,
+			method: "GET",
+			headers: this.buildHeaders(),
+			redirect: "error",
+			signal
+		});
+		if (response.status === 404) {
+			await releaseResponse(response, "Tempo");
+			return null;
+		}
+		if (!response.ok) {
+			await releaseResponse(response, "Tempo");
+			throw new TraceProviderError(`Tempo returned HTTP ${response.status}`, {
+				statusCode: response.status,
+				retryable: response.status === 408 || response.status === 429 || response.status >= 500
+			});
+		}
+		if (Number(response.headers.get("content-length")) > 10485760) {
+			await releaseResponse(response, "Tempo");
+			throw new TraceProviderError("Tempo trace exceeds the maximum response size");
+		}
+		const body = await readLimitedResponse(response, "Tempo");
+		const data = JSON.parse(body);
+		if (!Array.isArray(data.batches)) throw new TraceProviderError("Tempo returned an invalid trace response");
+		return {
+			spans: this.transformSpans(data, traceId),
+			fetchedAt: Date.now()
+		};
+	}
+};
+//#endregion
+//#region src/tracing/providers/index.ts
+/**
+* Create a trace provider instance based on configuration.
+*
+* @param config - Provider configuration specifying type and connection details
+* @returns A TraceProvider instance for the specified backend
+* @throws Error if the provider type is not supported or misconfigured
+*/
+function createTraceProvider(config) {
+	switch (config.id) {
+		case "braintrust": return new BraintrustProvider(config);
+		case "langfuse": return new LangfuseProvider(config);
+		case "tempo": return new TempoProvider(config);
+		case "local": throw new Error("Local provider id should use TraceStore directly, not createTraceProvider()");
+		default: throw new Error(`Unknown trace provider id: ${config.id}`);
+	}
+}
+/**
+* Check if a provider configuration specifies an external backend.
+* Returns true if the config has an id other than 'local' and has an endpoint.
+*
+* @param config - Optional provider configuration
+* @returns true if this is an external provider (Tempo, Jaeger, etc.)
+*/
+function isExternalTraceProvider(config) {
+	return !!config && config.id !== "local" && !!config.endpoint;
+}
+//#endregion
+//#region src/tracing/traceContext.ts
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 500;
+const DEFAULT_QUERY_DELAY_MS = 3e3;
+const EXTERNAL_SPAN_BATCH_SIZE = 500;
+const inFlightExternalFetches = /* @__PURE__ */ new WeakMap();
+const SPAN_KIND_MAP = {
+	0: "unspecified",
+	1: "internal",
+	2: "server",
+	3: "client",
+	4: "producer",
+	5: "consumer"
+};
+function resolveSpanKind(span) {
+	const attributes = span.attributes || {};
+	const attributeKind = attributes["span.kind"] || attributes["otel.span.kind"] || attributes["spanKind"] || attributes["kind"];
+	if (attributeKind) return `${attributeKind}`.toLowerCase();
+	const numericKind = attributes["otel.span.kind_code"];
+	if (typeof numericKind === "number" && numericKind in SPAN_KIND_MAP) return SPAN_KIND_MAP[numericKind];
+	return "unspecified";
+}
+function mapStatusCode(span) {
+	switch (span.statusCode) {
+		case 1: return "ok";
+		case 2: return "error";
+		default: return "unset";
+	}
+}
+function createTraceSpans(spans) {
+	const spansById = new Map(spans.map((span) => [span.spanId, span]));
+	const depthMap = /* @__PURE__ */ new Map();
+	return spans.map((span) => {
+		const durationMs = Math.max(0, (span.endTime ?? span.startTime) - span.startTime);
+		return {
+			spanId: span.spanId,
+			parentSpanId: span.parentSpanId,
+			name: span.name,
+			kind: resolveSpanKind(span),
+			startTime: span.startTime,
+			endTime: span.endTime,
+			durationMs,
+			attributes: span.attributes || {},
+			status: {
+				code: mapStatusCode(span),
+				message: span.statusMessage
+			},
+			depth: computeSpanDepth(span, spansById, depthMap) ?? 0,
+			events: []
+		};
+	});
+}
+function deriveInsights(traceSpans) {
+	if (traceSpans.length === 0) return [];
+	const insights = [];
+	traceSpans.filter((span) => span.status.code === "error").forEach((span) => {
+		const statusMessage = span.status.message ? `: ${span.status.message}` : "";
+		insights.push(`Error span "${span.name}" (${span.spanId.slice(0, 8)})${statusMessage}`);
+	});
+	traceSpans.map((span) => ({
+		span,
+		toolName: getToolNameFromAttributes(span.attributes)
+	})).filter((entry) => entry.toolName).forEach(({ span, toolName }) => {
+		insights.push(`Tool call ${toolName} via "${span.name}" (duration ${span.durationMs ?? 0}ms)`);
+	});
+	traceSpans.filter((span) => span.attributes["guardrail.name"] || span.attributes["guardrails.decision"]).forEach((span) => {
+		const decision = span.attributes["guardrails.decision"] ?? span.attributes["guardrail.decision"];
+		insights.push(`Guardrail ${span.attributes["guardrail.name"] ?? span.name} decision: ${decision ?? "unknown"}`);
+	});
+	return insights.slice(0, 20);
+}
+function extractTraceIdFromTraceparent(traceparent) {
+	if (!traceparent) return null;
+	const parts = traceparent.split("-");
+	const [version, traceId, parentSpanId, flags] = parts;
+	const validPartCount = version?.toLowerCase() === "00" ? parts.length === 4 : parts.length >= 4;
+	if (!/^[0-9a-f]{2}$/i.test(version) || version.toLowerCase() === "ff" || !validPartCount || !/^[0-9a-f]{32}$/i.test(traceId) || /^0+$/.test(traceId) || !/^[0-9a-f]{16}$/i.test(parentSpanId) || /^0+$/.test(parentSpanId) || !/^[0-9a-f]{2}$/i.test(flags)) return null;
+	return traceId.toLowerCase();
+}
+/**
+* Compute the depth of a span in the span tree, rejecting cyclic parent chains.
+*/
+function computeSpanDepth(span, spanMap, depthCache) {
+	const ancestors = [];
+	const visited = /* @__PURE__ */ new Set();
+	let current = span;
+	let depth = -1;
+	while (current) {
+		const cachedDepth = depthCache.get(current.spanId);
+		if (cachedDepth !== void 0) {
+			if (cachedDepth === null) {
+				for (const ancestor of ancestors) depthCache.set(ancestor.spanId, null);
+				return null;
+			}
+			depth = cachedDepth;
+			break;
+		}
+		if (visited.has(current.spanId)) {
+			for (const ancestor of ancestors) depthCache.set(ancestor.spanId, null);
+			return null;
+		}
+		visited.add(current.spanId);
+		ancestors.push(current);
+		current = current.parentSpanId ? spanMap.get(current.parentSpanId) : void 0;
+	}
+	for (let index = ancestors.length - 1; index >= 0; index--) {
+		depth += 1;
+		depthCache.set(ancestors[index].spanId, depth);
+	}
+	return depth;
+}
+/**
+* Drop malformed parent cycles before persisting or processing external spans.
+*/
+function discardCyclicExternalSpans(spans) {
+	const spanMap = new Map(spans.map((span) => [span.spanId, span]));
+	const depthCache = /* @__PURE__ */ new Map();
+	const cyclicSpanIds = /* @__PURE__ */ new Set();
+	const validSpans = spans.filter((span) => {
+		if (computeSpanDepth(span, spanMap, depthCache) === null) {
+			cyclicSpanIds.add(span.spanId);
+			return false;
+		}
+		return true;
+	});
+	if (cyclicSpanIds.size > 0) logger.warn(`[TraceContext] Skipping ${cyclicSpanIds.size} spans with cyclic parent relationships`);
+	return validSpans;
+}
+/**
+* Store spans fetched from an external provider in the local database.
+* This allows the spans to be displayed in the UI and persisted.
+*/
+async function storeExternalSpans(traceId, spans) {
+	try {
+		const traceStore = getTraceStore();
+		for (let index = 0; index < spans.length; index += EXTERNAL_SPAN_BATCH_SIZE) if (!(await traceStore.addSpans(traceId, spans.slice(index, index + EXTERNAL_SPAN_BATCH_SIZE), {
+			warnIfMissingTrace: false,
+			...index > 0 && { skipTraceCheck: true }
+		})).stored) return false;
+		logger.debug(`[TraceContext] Stored ${spans.length} spans from external provider`);
+		return true;
+	} catch (error) {
+		logger.warn(`[TraceContext] Failed to store external spans: ${error}`);
+		return false;
+	}
+}
+function redactExternalSpan(span, redactAttributes) {
+	const attributes = span.attributes ?? {};
+	const sanitizedAttributes = sanitizeTraceAttributes(attributes, {
+		redactAttributes,
+		sanitizeSensitiveAttributes: false,
+		truncateValues: false
+	});
+	const redactedValues = /* @__PURE__ */ new Set();
+	const pendingValues = [{
+		original: attributes,
+		sanitized: sanitizedAttributes
+	}];
+	while (pendingValues.length > 0) {
+		const { original, sanitized } = pendingValues.pop();
+		if (typeof original !== "object") {
+			if (original !== void 0 && sanitized === "[REDACTED]") {
+				const value = String(original);
+				if (value.length > 0) redactedValues.add(value);
+			}
+			continue;
+		}
+		if (!original) continue;
+		if (Array.isArray(original)) {
+			for (let index = 0; index < original.length; index++) pendingValues.push({
+				original: original[index],
+				sanitized: sanitized === "[REDACTED]" ? sanitized : sanitized?.[index]
+			});
+			continue;
+		}
+		for (const [key, value] of Object.entries(original)) pendingValues.push({
+			original: value,
+			sanitized: sanitized === "[REDACTED]" ? sanitized : sanitized?.[key]
+		});
+	}
+	const orderedRedactedValues = [...redactedValues].sort((left, right) => right.length - left.length);
+	const scrubEcho = (value) => {
+		if (typeof value !== "string") return value;
+		let sanitizedValue = value;
+		for (const redactedValue of orderedRedactedValues) sanitizedValue = sanitizedValue.split(redactedValue).join("[REDACTED]");
+		return sanitizedValue;
+	};
+	return {
+		...span,
+		name: scrubEcho(span.name),
+		statusMessage: scrubEcho(span.statusMessage),
+		attributes: sanitizedAttributes
+	};
+}
+function getProviderFetchOptions(spanOptions, abortSignal) {
+	const requiresPostFetchFiltering = spanOptions.includeInternalSpans === false || Boolean(spanOptions.spanFilter?.length);
+	const providerOptions = {
+		...spanOptions.earliestStartTime !== void 0 && { earliestStartTime: spanOptions.earliestStartTime },
+		...spanOptions.maxSpans !== void 0 && !requiresPostFetchFiltering && { maxSpans: spanOptions.maxSpans },
+		...abortSignal && { abortSignal }
+	};
+	return Object.keys(providerOptions).length > 0 ? providerOptions : void 0;
+}
+/**
+* Fetch trace context from an external provider (Tempo, Jaeger, etc.)
+*/
+async function fetchFromExternalProvider(traceId, providerConfig, options) {
+	const { queryDelay, maxRetries, retryDelayMs, redactAttributes, abortSignal, ...spanOptions } = options;
+	const providerFetchOptions = getProviderFetchOptions(spanOptions, abortSignal);
+	let provider;
+	try {
+		provider = createTraceProvider(providerConfig);
+	} catch (error) {
+		logger.warn(`[TraceContext] Failed to initialize trace provider: ${error}`);
+		return null;
+	}
+	if (queryDelay > 0) {
+		logger.debug(`[TraceContext] Waiting ${queryDelay}ms for spans to arrive at external backend`);
+		await waitForRetry(queryDelay, abortSignal);
+	}
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		if (abortSignal?.aborted) throw createTraceAbortError(abortSignal);
+		try {
+			const result = await provider.fetchTrace(traceId, providerFetchOptions);
+			const validSpans = result ? discardCyclicExternalSpans(result.spans) : [];
+			if (!result || validSpans.length === 0) {
+				if (attempt === maxRetries) {
+					logger.debug(`[TraceContext] No spans found for trace ${traceId} from ${provider.id} after ${attempt + 1} attempts`);
+					return null;
+				}
+				logger.debug(`[TraceContext] No spans yet for trace ${traceId} from ${provider.id}, retrying in ${retryDelayMs}ms (attempt ${attempt + 1}/${maxRetries})`);
+				await waitForRetry(retryDelayMs, abortSignal);
+				continue;
+			}
+			if (!await storeExternalSpans(traceId, redactAttributes?.length ? validSpans.map((span) => redactExternalSpan(span, redactAttributes)) : validSpans)) return null;
+			const spans = await getTraceStore().getSpans(traceId, spanOptions);
+			if (spans.length === 0) return null;
+			const traceSpans = createTraceSpans(spans);
+			const insights = deriveInsights(traceSpans);
+			logger.debug(`[TraceContext] Resolved ${traceSpans.length} spans for trace ${traceId} from ${provider.id} with ${insights.length} insights`);
+			return {
+				traceId,
+				spans: traceSpans,
+				insights,
+				fetchedAt: result.fetchedAt
+			};
+		} catch (error) {
+			if (abortSignal?.aborted) throw createTraceAbortError(abortSignal);
+			logger.error(`[TraceContext] Failed to fetch from ${provider.id}: ${error}`);
+			if (attempt === maxRetries || error instanceof TraceProviderError && !error.retryable) return null;
+			await waitForRetry(retryDelayMs, abortSignal);
+		}
+	}
+	return null;
+}
+function createTraceAbortError(signal) {
+	const error = /* @__PURE__ */ new Error("cancelled by user");
+	error.cause = signal?.reason;
+	error.name = "AbortError";
+	return error;
+}
+async function waitForRetry(delay, signal) {
+	if (signal?.aborted) throw createTraceAbortError(signal);
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(createTraceAbortError(signal));
+		};
+		const timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, delay);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Fetch trace context from local TraceStore (SQLite)
+*/
+async function fetchFromLocalStore(traceId, options) {
+	const { maxRetries, retryDelayMs, abortSignal, redactAttributes, ...spanOptions } = options;
+	const traceStore = getTraceStore();
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		if (abortSignal?.aborted) throw createTraceAbortError(abortSignal);
+		try {
+			const spans = await traceStore.getSpans(traceId, spanOptions);
+			if (spans.length === 0) {
+				if (attempt === maxRetries) {
+					logger.debug(`[TraceContext] No spans found for trace ${traceId} after ${attempt + 1} attempts`);
+					return null;
+				}
+				logger.debug(`[TraceContext] No spans yet for trace ${traceId}, retrying in ${retryDelayMs}ms (attempt ${attempt + 1}/${maxRetries})`);
+				await waitForRetry(retryDelayMs, abortSignal);
+				continue;
+			}
+			const traceSpans = createTraceSpans(redactAttributes?.length ? spans.map((span) => ({
+				...span,
+				attributes: sanitizeTraceAttributes(span.attributes, {
+					redactAttributes,
+					sanitizeSensitiveAttributes: spanOptions.sanitizeAttributes
+				})
+			})) : spans);
+			const insights = deriveInsights(traceSpans);
+			const context = {
+				traceId,
+				spans: traceSpans,
+				insights,
+				fetchedAt: Date.now()
+			};
+			logger.debug(`[TraceContext] Resolved ${traceSpans.length} spans for trace ${traceId} with ${insights.length} insights`);
+			return context;
+		} catch (error) {
+			if (abortSignal?.aborted) throw createTraceAbortError(abortSignal);
+			logger.error(`[TraceContext] Failed to fetch spans for trace ${traceId}: ${error}`);
+			if (attempt === maxRetries) return null;
+			await waitForRetry(retryDelayMs, abortSignal);
+		}
+	}
+	return null;
+}
+/**
+* Fetch trace context for a given trace ID.
+*
+* If an external provider is configured (Tempo, Jaeger, etc.), fetches from that backend.
+* Otherwise, fetches from the local TraceStore (SQLite).
+*
+* @param traceId - The W3C trace ID (32 hex chars)
+* @param options - Fetch options including provider config
+* @returns TraceContextData or null if not found
+*/
+async function fetchTraceContext(traceId, options = {}) {
+	const { includeInternalSpans = true, sanitizeAttributes = true, maxRetries = DEFAULT_MAX_RETRIES, retryDelayMs = DEFAULT_RETRY_DELAY_MS, providerConfig, queryDelay = DEFAULT_QUERY_DELAY_MS, ...spanOptions } = options;
+	const fetchOptions = {
+		maxRetries,
+		retryDelayMs,
+		includeInternalSpans,
+		sanitizeAttributes,
+		...spanOptions
+	};
+	if (isExternalTraceProvider(providerConfig)) {
+		const externalConfig = providerConfig;
+		const requestOptions = {
+			queryDelay,
+			...fetchOptions
+		};
+		if (requestOptions.abortSignal) return fetchFromExternalProvider(traceId, externalConfig, requestOptions);
+		const key = JSON.stringify({
+			traceId,
+			...requestOptions
+		});
+		let pending = inFlightExternalFetches.get(externalConfig);
+		if (!pending) {
+			pending = /* @__PURE__ */ new Map();
+			inFlightExternalFetches.set(externalConfig, pending);
+		}
+		const existing = pending.get(key);
+		if (existing) return existing;
+		const request = fetchFromExternalProvider(traceId, externalConfig, requestOptions).finally(() => pending.delete(key));
+		pending.set(key, request);
+		return request;
+	}
+	return fetchFromLocalStore(traceId, fetchOptions);
+}
+//#endregion
+export { fetchTraceContext as n, isExternalTraceProvider as r, extractTraceIdFromTraceparent as t };
+
+//# sourceMappingURL=traceContext-Brw3Oe41.js.map