@tangle-network/sdk-telemetry 0.1.8

package/dist/index.mjs

@@ -0,0 +1,2170 @@
+import { PROVISION_TRACE_ID_HEADER, PTID_PREFIX, SpanRecorder, isAdoptablePtid, mintPtid, monotonicNs, parseServerTiming, readOrMintPtid, spanDurationMs } from "./stage-span.mjs";
+import { GEN_AI_CONVERSATION_ID, GEN_AI_CONVERSATION_ID as GEN_AI_CONVERSATION_ID$1, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_NAME as GEN_AI_OPERATION_NAME$1, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_REQUEST_MODEL as GEN_AI_REQUEST_MODEL$1, GEN_AI_RESPONSE_MODEL, GEN_AI_RESPONSE_MODEL as GEN_AI_RESPONSE_MODEL$1, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_INPUT_TOKENS as GEN_AI_USAGE_INPUT_TOKENS$1, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS as GEN_AI_USAGE_OUTPUT_TOKENS$1, SSEChunkParser, StreamUsageExtractor, TOKEN_USAGE_COST_KEYS, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, addTokenUsage, consumeSSEStream, createStreamUsageExtractor, createUsageCallback, firstTokenCount, firstUsageCostUsd, genAiUsageAttributes, isFilePart, isReasoningPart, isTextPart, isToolPart, parseSSEData as parseSSEData$1, parseSSEStream, readTokenCostUsd, readTokenUsage, tokenCount, tokenUsageSource } from "@tangle-network/agent-core";
+//#region src/credits.ts
+const DEFAULT_CONFIG$2 = {
+	refreshIntervalMs: 6e4,
+	warningThreshold: .2,
+	criticalThreshold: .05
+};
+var CreditTracker = class {
+	config;
+	provider;
+	storage;
+	cachedBalance;
+	lastRefresh;
+	refreshTimer;
+	reservations = /* @__PURE__ */ new Map();
+	constructor(config, provider, storage) {
+		this.config = {
+			...DEFAULT_CONFIG$2,
+			...config
+		};
+		this.provider = provider;
+		this.storage = storage;
+		if (this.config.refreshIntervalMs > 0) this.startRefreshTimer();
+	}
+	async getBalance(forceRefresh = false) {
+		if (forceRefresh || !this.cachedBalance || this.isStale()) {
+			this.cachedBalance = await this.provider.getBalance();
+			this.lastRefresh = /* @__PURE__ */ new Date();
+			this.checkThresholds(this.cachedBalance);
+			if (this.storage) await this.storage.set(`credits:${this.config.projectRef}:balance`, this.cachedBalance);
+			this.config.onBalanceUpdate?.(this.cachedBalance);
+		}
+		return this.cachedBalance;
+	}
+	async getTransactions(options) {
+		return this.provider.getTransactions(options);
+	}
+	async hasCredits(amount) {
+		const balance = await this.getBalance();
+		const reservedTotal = this.getReservedTotal();
+		return balance.available - reservedTotal >= amount;
+	}
+	async reserve(amount, options) {
+		if (!await this.hasCredits(amount)) return null;
+		const reservationId = await this.provider.reserveCredit(amount);
+		if (!reservationId) return null;
+		const now = /* @__PURE__ */ new Date();
+		this.reservations.set(reservationId, {
+			amount,
+			createdAt: now,
+			expiresAt: options?.ttlMs ? new Date(now.getTime() + options.ttlMs) : void 0
+		});
+		return reservationId;
+	}
+	async release(reservationId) {
+		await this.provider.releaseReservation(reservationId);
+		this.reservations.delete(reservationId);
+	}
+	async charge(reservationId, actualAmount) {
+		const transaction = await this.provider.chargeReservation(reservationId, actualAmount);
+		this.reservations.delete(reservationId);
+		await this.getBalance(true);
+		return transaction;
+	}
+	async chargeImmediate(amount, _description) {
+		const reservationId = await this.reserve(amount);
+		if (!reservationId) return null;
+		return this.charge(reservationId, amount);
+	}
+	getReservedTotal() {
+		this.cleanupExpiredReservations();
+		let total = 0;
+		for (const reservation of this.reservations.values()) total += reservation.amount;
+		return total;
+	}
+	getEffectiveBalance() {
+		const balance = this.cachedBalance;
+		if (!balance) return 0;
+		return balance.available - this.getReservedTotal();
+	}
+	getUsagePercent() {
+		const balance = this.cachedBalance;
+		if (!balance || balance.limit === 0) return 0;
+		return balance.used / balance.limit * 100;
+	}
+	getRemainingPercent() {
+		const balance = this.cachedBalance;
+		if (!balance || balance.limit === 0) return 100;
+		return balance.available / balance.limit * 100;
+	}
+	isLow() {
+		return this.getRemainingPercent() / 100 <= this.config.warningThreshold;
+	}
+	isCritical() {
+		return this.getRemainingPercent() / 100 <= this.config.criticalThreshold;
+	}
+	async close() {
+		this.stopRefreshTimer();
+		for (const [id] of this.reservations) try {
+			await this.release(id);
+		} catch {}
+	}
+	isStale() {
+		if (!this.lastRefresh) return true;
+		return Date.now() - this.lastRefresh.getTime() > this.config.refreshIntervalMs;
+	}
+	checkThresholds(balance) {
+		if (!balance.limit || balance.limit <= 0) return;
+		const remainingPercent = balance.available / balance.limit;
+		if (remainingPercent <= this.config.criticalThreshold) this.config.onCriticalBalance?.(balance);
+		else if (remainingPercent <= this.config.warningThreshold) this.config.onLowBalance?.(balance);
+	}
+	cleanupExpiredReservations() {
+		const now = Date.now();
+		for (const [id, reservation] of this.reservations) if (reservation.expiresAt && reservation.expiresAt.getTime() < now) this.reservations.delete(id);
+	}
+	startRefreshTimer() {
+		if (this.refreshTimer) return;
+		this.refreshTimer = setInterval(() => this.getBalance(true), this.config.refreshIntervalMs);
+	}
+	stopRefreshTimer() {
+		if (this.refreshTimer) {
+			clearInterval(this.refreshTimer);
+			this.refreshTimer = void 0;
+		}
+	}
+};
+var MemoryCreditProvider = class {
+	balance;
+	transactions = [];
+	reservations = /* @__PURE__ */ new Map();
+	constructor(initialBalance = {}) {
+		this.balance = {
+			available: initialBalance.available ?? 1e3,
+			used: initialBalance.used ?? 0,
+			limit: initialBalance.limit ?? 1e3,
+			currency: initialBalance.currency ?? "credits"
+		};
+	}
+	async getBalance() {
+		return { ...this.balance };
+	}
+	async getTransactions(options) {
+		let result = [...this.transactions];
+		if (options?.since) {
+			const since = options.since;
+			result = result.filter((t) => t.timestamp >= since);
+		}
+		result = result.slice(options?.offset ?? 0, (options?.offset ?? 0) + (options?.limit ?? 100));
+		return result;
+	}
+	async checkCredit(amount) {
+		const reservedTotal = Array.from(this.reservations.values()).reduce((sum, amt) => sum + amt, 0);
+		return this.balance.available - reservedTotal >= amount;
+	}
+	async reserveCredit(amount) {
+		if (!await this.checkCredit(amount)) return null;
+		const id = `res-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+		this.reservations.set(id, amount);
+		return id;
+	}
+	async releaseReservation(reservationId) {
+		this.reservations.delete(reservationId);
+	}
+	async chargeReservation(reservationId, actualAmount) {
+		const reserved = this.reservations.get(reservationId);
+		if (reserved === void 0) throw new Error(`Reservation not found: ${reservationId}`);
+		const chargeAmount = actualAmount ?? reserved;
+		this.reservations.delete(reservationId);
+		this.balance.available -= chargeAmount;
+		this.balance.used += chargeAmount;
+		const transaction = {
+			id: `txn-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+			type: "charge",
+			amount: chargeAmount,
+			balance: this.balance.available,
+			description: `Charged from reservation ${reservationId}`,
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		this.transactions.unshift(transaction);
+		return transaction;
+	}
+	addCredits(amount, description) {
+		this.balance.available += amount;
+		this.balance.limit += amount;
+		const transaction = {
+			id: `txn-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+			type: "grant",
+			amount,
+			balance: this.balance.available,
+			description,
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		this.transactions.unshift(transaction);
+		return transaction;
+	}
+};
+function createCreditTracker(config, provider, storage) {
+	return new CreditTracker(config, provider, storage);
+}
+//#endregion
+//#region src/internal/best-effort.ts
+/**
+* Local best-effort helpers. Mirrors `@repo/shared/best-effort` but kept
+* inline so this published SDK package has no private workspace deps.
+*/
+function bestEffort(fn) {
+	try {
+		return fn();
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/enrichment/types.ts
+/** Create an empty enrichment context with defaults */
+function createEmptyContext() {
+	return { customLabels: {} };
+}
+//#endregion
+//#region src/enrichment/adapter-registry.ts
+/**
+* Adapter Registry
+*
+* Registry for metadata blob adapters. Adapters are tried in order of registration
+* until one can parse the blob. Default JSON adapter is always available.
+*/
+/** Registry for metadata blob adapters */
+var AdapterRegistry = class {
+	adapters = [];
+	/** Register an adapter (added to end of chain) */
+	register(adapter) {
+		if (this.adapters.find((a) => a.name === adapter.name)) throw new Error(`Adapter "${adapter.name}" already registered`);
+		this.adapters.push(adapter);
+	}
+	/** Unregister an adapter by name */
+	unregister(name) {
+		const idx = this.adapters.findIndex((a) => a.name === name);
+		if (idx >= 0) {
+			this.adapters.splice(idx, 1);
+			return true;
+		}
+		return false;
+	}
+	/** Get all registered adapter names */
+	getAdapterNames() {
+		return this.adapters.map((a) => a.name);
+	}
+	/**
+	* Parse a metadata blob using registered adapters.
+	* Returns enrichment context with parsed fields.
+	* Stores original blob in rawBlob for audit.
+	*/
+	parse(blob) {
+		const context = createEmptyContext();
+		context.rawBlob = blob;
+		for (const adapter of this.adapters) if (adapter.canParse(blob)) {
+			const parsed = bestEffort(() => adapter.parse(blob));
+			if (parsed) return {
+				...context,
+				...parsed,
+				customLabels: {
+					...context.customLabels,
+					...parsed.customLabels || {}
+				},
+				rawBlob: blob
+			};
+		}
+		return context;
+	}
+	/** Check if any adapter can parse the given blob */
+	canParse(blob) {
+		return this.adapters.some((a) => a.canParse(blob));
+	}
+};
+/** Default global registry instance */
+let defaultRegistry = null;
+/** Get or create the default adapter registry */
+function getDefaultRegistry() {
+	if (!defaultRegistry) defaultRegistry = new AdapterRegistry();
+	return defaultRegistry;
+}
+/** Reset the default registry (for testing) */
+function resetDefaultRegistry() {
+	defaultRegistry = null;
+}
+//#endregion
+//#region src/enrichment/json-adapter.ts
+const VALID_PRODUCTS = [
+	"vibe_coding",
+	"simulation",
+	"background_agent"
+];
+const VALID_ENVIRONMENTS = [
+	"development",
+	"staging",
+	"production"
+];
+const VALID_TIERS = [
+	"free",
+	"pro",
+	"enterprise"
+];
+function normalizeProduct(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.toLowerCase().replace(/-/g, "_");
+	return VALID_PRODUCTS.includes(normalized) ? normalized : void 0;
+}
+function normalizeEnvironment(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.toLowerCase();
+	if (normalized === "dev") return "development";
+	if (normalized === "prod") return "production";
+	return VALID_ENVIRONMENTS.includes(normalized) ? normalized : void 0;
+}
+function normalizeTier(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.toLowerCase();
+	return VALID_TIERS.includes(normalized) ? normalized : void 0;
+}
+/** JSON adapter for parsing metadata blobs */
+const jsonAdapter = {
+	name: "json",
+	canParse(blob) {
+		return blob.format === "json";
+	},
+	parse(blob) {
+		const dataStr = typeof blob.data === "string" ? blob.data : blob.data.toString("utf-8");
+		const payload = JSON.parse(dataStr);
+		const context = { customLabels: {} };
+		const partnerId = payload.partner_id || payload.partnerId;
+		if (typeof partnerId === "string" && partnerId.length > 0) context.partnerId = partnerId;
+		context.subscriptionTier = normalizeTier(payload.subscription_tier || payload.subscriptionTier);
+		const userId = payload.end_user_id || payload.endUserId || payload.user_id || payload.userId;
+		if (typeof userId === "string" && userId.length > 0) context.endUserId = userId;
+		context.product = normalizeProduct(payload.product);
+		context.environment = normalizeEnvironment(payload.environment || payload.env);
+		const customLabels = {};
+		const addLabels = (obj) => {
+			if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+				for (const [key, value] of Object.entries(obj)) if (typeof value === "string") customLabels[key] = value;
+				else if (typeof value === "number" || typeof value === "boolean") customLabels[key] = String(value);
+			}
+		};
+		addLabels(payload.custom);
+		addLabels(payload.labels);
+		if (Object.keys(customLabels).length > 0) context.customLabels = customLabels;
+		return context;
+	}
+};
+/** Create a JSON adapter instance */
+function createJsonAdapter() {
+	return jsonAdapter;
+}
+//#endregion
+//#region src/enrichment/index.ts
+/**
+* Initialize the default registry with built-in adapters.
+* Call this at startup to ensure JSON adapter is available.
+*/
+function initializeDefaultAdapters() {
+	const registry = getDefaultRegistry();
+	if (!registry.getAdapterNames().includes("json")) registry.register(jsonAdapter);
+}
+/**
+* Parse a metadata blob using the default registry.
+* Convenience function for common use case.
+*/
+function parseMetadataBlob(blob) {
+	initializeDefaultAdapters();
+	return getDefaultRegistry().parse(blob);
+}
+//#endregion
+//#region src/trace-types.ts
+/** Type guard for MessagePartUpdatedEvent */
+function isMessagePartUpdatedEvent(event) {
+	return event.type === "message.part.updated";
+}
+function isMessageUpdatedEvent(event) {
+	return event.type === "message.updated";
+}
+function isErrorEvent(event) {
+	return event.type === "error";
+}
+function isDiagnosticEvent(event) {
+	return event.type === "diagnostic";
+}
+function isFileChangeEvent(event) {
+	return event.type === "file_change";
+}
+function isBuildResultEvent(event) {
+	return event.type === "build_result";
+}
+function isTestResultEvent(event) {
+	return event.type === "test_result";
+}
+function isEnvironmentEvent(event) {
+	return event.type === "environment";
+}
+function isCustomEvent(event) {
+	return event.type === "custom";
+}
+//#endregion
+//#region src/langfuse-sink.ts
+let langfuseClient = null;
+let langfuseConfig = null;
+/**
+* Get or create the Langfuse client
+*/
+async function getLangfuseClient(config) {
+	if (langfuseClient && langfuseConfig === config) return langfuseClient;
+	try {
+		const { Langfuse } = await import("langfuse-node");
+		langfuseClient = new Langfuse({
+			publicKey: config.publicKey,
+			secretKey: config.secretKey,
+			baseUrl: config.baseUrl || "https://cloud.langfuse.com"
+		});
+		langfuseConfig = config;
+		return langfuseClient;
+	} catch (err) {
+		console.warn("[langfuse-sink] Failed to initialize Langfuse:", err);
+		return null;
+	}
+}
+/**
+* Langfuse trace exporter using the native SDK.
+*
+* Creates proper Langfuse traces with spans and generations
+* for rich observability in the Langfuse dashboard.
+*
+* Note: This is a trace-level exporter (ExecutionTrace), not a
+* TelemetrySink (TelemetryEvent). Use for exporting complete traces.
+*/
+var LangfuseSink = class {
+	name = "langfuse";
+	config;
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Export an execution trace to Langfuse.
+	*/
+	async exportTrace(trace) {
+		const client = await getLangfuseClient(this.config);
+		if (!client) return;
+		try {
+			const langfuseTrace = client.trace({
+				id: trace.id,
+				name: trace.task,
+				sessionId: trace.scope.sessionId,
+				userId: trace.scope.userId,
+				metadata: {
+					outcome: trace.outcome,
+					projectRef: trace.scope.projectRef,
+					...trace.metadata
+				},
+				tags: trace.outcome === "failure" ? ["failed"] : void 0
+			});
+			for (const event of trace.events) {
+				if (!event) continue;
+				this.exportTraceEvent(langfuseTrace, event);
+			}
+			for (const signal of trace.signals) langfuseTrace.event({
+				name: `signal.${signal.signal}`,
+				startTime: signal.timestamp,
+				metadata: signal.metadata
+			});
+			langfuseTrace.update({ output: trace.outcome });
+			await client.flushAsync();
+		} catch (err) {
+			console.warn("[langfuse-sink] Failed to export trace:", err);
+		}
+	}
+	/**
+	* Export a trace event as a Langfuse span or generation.
+	*/
+	exportTraceEvent(trace, event) {
+		switch (event.type) {
+			case "message.part.updated": {
+				const partEvent = event;
+				const part = partEvent.part;
+				if (isToolPart(part)) this.exportToolPart(trace, partEvent, part);
+				else if (isTextPart(part) || isReasoningPart(part)) trace.generation({
+					name: part.type === "reasoning" ? "reasoning" : "text",
+					startTime: partEvent.timestamp,
+					output: part.text,
+					metadata: {
+						partId: part.id,
+						sessionID: part.sessionID,
+						messageID: part.messageID,
+						delta: partEvent.delta
+					}
+				});
+				else if (isFilePart(part)) trace.event({
+					name: `file.${part.mediaType || "unknown"}`,
+					startTime: partEvent.timestamp,
+					metadata: {
+						partId: part.id,
+						filename: part.filename,
+						mediaType: part.mediaType,
+						url: part.url
+					}
+				});
+				break;
+			}
+			case "message.updated":
+				trace.event({
+					name: "message.updated",
+					startTime: event.timestamp,
+					metadata: {
+						text: event.text ?? event.finalText,
+						finalText: event.finalText,
+						tokenUsage: event.tokenUsage,
+						timing: event.timing,
+						toolInvocations: event.toolInvocations,
+						metadata: event.metadata
+					}
+				});
+				break;
+			case "error":
+				trace.event({
+					name: `error.${event.category}`,
+					startTime: event.timestamp,
+					level: "ERROR",
+					metadata: {
+						message: event.message,
+						code: event.code,
+						source: event.source
+					}
+				});
+				break;
+			case "file_change":
+				trace.event({
+					name: `file.${event.changeType}`,
+					startTime: event.timestamp,
+					metadata: {
+						file: event.file,
+						linesAdded: event.linesAdded,
+						linesRemoved: event.linesRemoved
+					}
+				});
+				break;
+			case "build_result":
+				trace.span({
+					name: `build.${event.success ? "success" : "failure"}`,
+					startTime: event.timestamp,
+					endTime: event.durationMs ? new Date(event.timestamp.getTime() + event.durationMs) : void 0,
+					output: event.success ? "success" : "failed",
+					metadata: {
+						command: event.command,
+						errorCount: event.errorCount,
+						warningCount: event.warningCount
+					},
+					level: event.success ? void 0 : "ERROR"
+				});
+				break;
+			case "test_result":
+				trace.span({
+					name: `test.${event.success ? "success" : "failure"}`,
+					startTime: event.timestamp,
+					endTime: event.durationMs ? new Date(event.timestamp.getTime() + event.durationMs) : void 0,
+					output: event.success ? "success" : "failed",
+					metadata: {
+						command: event.command,
+						passed: event.passed,
+						failed: event.failed,
+						skipped: event.skipped
+					},
+					level: event.success ? void 0 : "ERROR"
+				});
+				break;
+			case "diagnostic":
+				trace.event({
+					name: `diagnostic.${event.language || "unknown"}`,
+					startTime: event.timestamp,
+					metadata: {
+						file: event.file,
+						errorDelta: event.errorDelta,
+						errorsAfter: event.afterSummary.errors,
+						warningsAfter: event.afterSummary.warnings
+					}
+				});
+				break;
+			case "environment":
+				trace.event({
+					name: "environment.snapshot",
+					startTime: event.timestamp,
+					metadata: {
+						workingDir: event.workingDir,
+						platform: event.platform
+					}
+				});
+				break;
+			case "custom":
+				if (event.name === "startup.phase") {
+					const durationMs = typeof event.data.durationMs === "number" ? event.data.durationMs : 0;
+					const phase = typeof event.data.phase === "string" ? event.data.phase : "unknown";
+					trace.span({
+						name: `startup.${phase}`,
+						startTime: new Date(event.timestamp.getTime() - durationMs),
+						endTime: event.timestamp,
+						metadata: event.data,
+						level: event.data.status === "error" ? "ERROR" : void 0,
+						statusMessage: typeof event.data.error === "string" ? event.data.error : void 0
+					});
+				} else trace.event({
+					name: `custom.${event.name}`,
+					startTime: event.timestamp,
+					metadata: event.data
+				});
+				break;
+		}
+	}
+	/**
+	* Export a tool part from message.part.updated event.
+	* Tool parts have state progression: pending → running → completed/error
+	*/
+	exportToolPart(trace, event, part) {
+		const status = part.state.status;
+		const toolName = part.tool;
+		if (status === "running") trace.span({
+			name: `tool.${toolName}`,
+			startTime: event.timestamp,
+			input: part.state.input ?? { callID: part.callID },
+			metadata: {
+				partId: part.id,
+				sessionID: part.sessionID,
+				messageID: part.messageID,
+				status
+			}
+		});
+		else if (status === "completed") {
+			const endTime = part.state.time?.end ? new Date(part.state.time.end) : event.timestamp;
+			const startTime = part.state.time?.start ? new Date(part.state.time.start) : event.timestamp;
+			trace.span({
+				name: `tool.${toolName}.result`,
+				startTime,
+				endTime,
+				input: part.state.input,
+				output: part.state.output ?? "success",
+				metadata: {
+					partId: part.id,
+					sessionID: part.sessionID,
+					messageID: part.messageID,
+					callID: part.callID,
+					success: true
+				}
+			});
+		} else if (status === "failed" || status === "error") {
+			const endTime = part.state.time?.end ? new Date(part.state.time.end) : event.timestamp;
+			const startTime = part.state.time?.start ? new Date(part.state.time.start) : event.timestamp;
+			trace.span({
+				name: `tool.${toolName}.result`,
+				startTime,
+				endTime,
+				input: part.state.input,
+				output: part.state.output ?? part.state.error,
+				metadata: {
+					partId: part.id,
+					sessionID: part.sessionID,
+					messageID: part.messageID,
+					callID: part.callID,
+					success: false
+				},
+				level: "ERROR",
+				statusMessage: part.state.error
+			});
+		}
+	}
+	async flush() {
+		const client = await getLangfuseClient(this.config);
+		if (client) await client.flushAsync();
+	}
+	async close() {
+		const client = await getLangfuseClient(this.config);
+		if (client) {
+			await client.shutdownAsync();
+			langfuseClient = null;
+		}
+	}
+};
+/**
+* Create a Langfuse sink from environment variables.
+*/
+function createLangfuseSinkFromEnv() {
+	const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
+	const secretKey = process.env.LANGFUSE_SECRET_KEY;
+	if (!publicKey || !secretKey) return null;
+	return new LangfuseSink({
+		publicKey,
+		secretKey,
+		baseUrl: process.env.LANGFUSE_HOST || "https://cloud.langfuse.com",
+		debug: process.env.LANGFUSE_DEBUG === "true"
+	});
+}
+//#endregion
+//#region src/otel-provider.ts
+let provider = null;
+/** Parse `OTEL_EXPORTER_OTLP_HEADERS` ("k=v,k2=v2") into a header map. */
+function parseHeaders(raw) {
+	const out = {};
+	if (!raw) return out;
+	for (const pair of raw.split(",")) {
+		const eq = pair.indexOf("=");
+		if (eq <= 0) continue;
+		const key = pair.slice(0, eq).trim();
+		const value = pair.slice(eq + 1).trim();
+		if (key) out[key] = value;
+	}
+	return out;
+}
+async function initOtelProvider(serviceName) {
+	if (provider) return { active: true };
+	if (process.env.TELEMETRY_ENABLED !== "true") return {
+		active: false,
+		reason: "TELEMETRY_ENABLED!=true"
+	};
+	const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	if (!endpoint) return {
+		active: false,
+		reason: "OTEL_EXPORTER_OTLP_ENDPOINT unset"
+	};
+	try {
+		const [{ NodeTracerProvider, BatchSpanProcessor }, { OTLPTraceExporter }, { resourceFromAttributes }, { ATTR_SERVICE_NAME }] = await Promise.all([
+			import("@opentelemetry/sdk-trace-node"),
+			import("@opentelemetry/exporter-trace-otlp-http"),
+			import("@opentelemetry/resources"),
+			import("@opentelemetry/semantic-conventions")
+		]);
+		const exporter = new OTLPTraceExporter({
+			url: endpoint,
+			headers: parseHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS)
+		});
+		const tracerProvider = new NodeTracerProvider({
+			resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName }),
+			spanProcessors: [new BatchSpanProcessor(exporter)]
+		});
+		tracerProvider.register();
+		provider = tracerProvider;
+		return { active: true };
+	} catch (error) {
+		return {
+			active: false,
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function shutdownOtelProvider() {
+	if (!provider) return;
+	const current = provider;
+	provider = null;
+	try {
+		await current.forceFlush();
+	} catch {}
+	await current.shutdown();
+}
+//#endregion
+//#region src/otel-sink.ts
+/**
+* OpenTelemetry Sink
+*
+* Exports telemetry data to OpenTelemetry-compatible backends including
+* Langfuse, Jaeger, Honeycomb, and other OTLP collectors.
+*
+* IMPORTANT: This sink uses the GLOBAL tracer from @opentelemetry/api.
+* The OTEL SDK must be initialized separately (e.g., via NodeSDK with
+* LangfuseSpanProcessor or OTLPTraceExporter) before using this sink.
+*
+* This sink converts ExecutionTrace data into OTEL spans using the
+* global tracer, which ensures spans flow through whatever processor
+* was configured at SDK initialization.
+*/
+/**
+* GenAI semantic-convention keys promoted from a `message.updated` event's
+* metadata bag to DISCRETE span attributes. The intelligence ingest derives
+* model/token/cost and conversation linkage by reading these exact keys off the
+* flat span attribute bag (`parseGenAiAttribution` / `parseConversationLinkage`
+* in the intelligence API); leaving them inside the serialized `message.metadata`
+* blob would attribute every auto-instrumented LLM call as model/tokens/cost
+* unknown. Promotion is unconditional (not gated on `includePayloads`): these
+* are attribution signal, not prompt/completion content. `genAiUsageAttributes`
+* already guarantees the writer never emits a fabricated zero, so a key absent
+* here stays absent on the span — "cost not computed", never "free".
+*/
+const GEN_AI_PROMOTED_KEYS = Object.freeze([
+	GEN_AI_REQUEST_MODEL$1,
+	GEN_AI_RESPONSE_MODEL$1,
+	GEN_AI_USAGE_INPUT_TOKENS$1,
+	GEN_AI_USAGE_OUTPUT_TOKENS$1,
+	GEN_AI_OPERATION_NAME$1,
+	GEN_AI_CONVERSATION_ID$1
+]);
+/**
+* Build the parent-span attributes for a trace, with a deliberate precedence:
+* partner-supplied `resourceAttributes` are the LOWEST layer, so the trusted
+* identity attributes (agent.trace.id, session.id, user.id) and metadata always
+* override a colliding key. A partner cannot spoof span identity by passing a
+* `resourceAttributes` key like `session.id`.
+*/
+function buildTraceSpanAttributes(trace, flattenedMetadata) {
+	return {
+		...trace.scope.resourceAttributes ?? {},
+		"agent.trace.id": trace.id,
+		"agent.task": trace.task,
+		"agent.outcome": trace.outcome,
+		"langfuse.trace.id": trace.id,
+		"langfuse.trace.name": trace.task,
+		...trace.scope.projectRef && { "langfuse.project": trace.scope.projectRef },
+		...trace.scope.sessionId && {
+			"langfuse.session.id": trace.scope.sessionId,
+			"session.id": trace.scope.sessionId
+		},
+		...trace.scope.userId && {
+			"langfuse.user.id": trace.scope.userId,
+			"user.id": trace.scope.userId
+		},
+		...flattenedMetadata ?? {}
+	};
+}
+let otelApi = null;
+/**
+* Load the OTEL API dynamically
+*/
+async function getOtelApi() {
+	if (!otelApi) try {
+		otelApi = await import("@opentelemetry/api");
+	} catch {
+		return null;
+	}
+	return otelApi;
+}
+/**
+* OpenTelemetry sink — exports via whatever OTEL SDK config was set at
+* application startup (Langfuse, Jaeger, any OTLP backend).
+*/
+var OtelTelemetrySink = class {
+	name = "otel";
+	config;
+	constructor(config = {}) {
+		this.config = {
+			serviceName: config.serviceName ?? "agent-sdk",
+			includePayloads: config.includePayloads ?? false
+		};
+	}
+	async send(events) {
+		const api = await getOtelApi();
+		if (!api) return;
+		const tracer = api.trace.getTracer(this.config.serviceName, "1.0.0");
+		for (const event of events) {
+			if (event.type === "agent_execution" && this.isExecutionTrace(event.data.trace)) {
+				await this.exportTrace(event.data.trace);
+				continue;
+			}
+			const span = tracer.startSpan(`telemetry.${event.type}.${event.name}`, {
+				attributes: {
+					"telemetry.event.type": event.type,
+					"telemetry.event.name": event.name
+				},
+				startTime: event.timestamp
+			});
+			if (event.data && typeof event.data === "object") {
+				for (const [key, value] of Object.entries(event.data)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") span.setAttribute(`telemetry.data.${key}`, value);
+			}
+			span.setStatus({ code: api.SpanStatusCode.OK });
+			span.end();
+		}
+	}
+	/**
+	* Export an execution trace as OTEL spans.
+	*
+	* Creates a parent span for the trace and child spans for each event.
+	* Uses the global tracer, so spans flow through the configured processor.
+	*/
+	async exportTrace(trace) {
+		const api = await getOtelApi();
+		if (!api) return;
+		const tracer = api.trace.getTracer(this.config.serviceName, "1.0.0");
+		const traceSpan = tracer.startSpan("agent.task", {
+			attributes: buildTraceSpanAttributes(trace, trace.metadata ? this.flattenMetadata(trace.metadata) : void 0),
+			startTime: trace.startedAt
+		});
+		const parentContext = api.trace.setSpan(api.context.active(), traceSpan);
+		for (const event of trace.events) {
+			if (!event?.type) continue;
+			api.context.with(parentContext, () => {
+				this.exportTraceEvent(tracer, api, event);
+			});
+		}
+		for (const signal of trace.signals) traceSpan.addEvent(`signal.${signal.signal}`, {}, signal.timestamp);
+		if (trace.outcome === "failure") traceSpan.setStatus({
+			code: api.SpanStatusCode.ERROR,
+			message: "Task failed"
+		});
+		else traceSpan.setStatus({ code: api.SpanStatusCode.OK });
+		traceSpan.end(trace.completedAt || /* @__PURE__ */ new Date());
+	}
+	/**
+	* Export a single trace event as an OTEL span.
+	*/
+	exportTraceEvent(tracer, api, event) {
+		const spanName = this.getSpanName(event);
+		const attributes = this.getEventAttributes(event);
+		const startTime = this.getEventStartTime(event);
+		const endTime = this.getEventEndTime(event);
+		const span = tracer.startSpan(spanName, {
+			attributes,
+			startTime
+		});
+		if (event.type === "error") {
+			span.setStatus({
+				code: api.SpanStatusCode.ERROR,
+				message: event.message
+			});
+			span.recordException(new Error(event.message));
+		} else if (event.type === "message.part.updated" && isToolPart(event.part)) {
+			const status = event.part.state.status;
+			if (status === "failed" || status === "error") {
+				const err = typeof event.part.state.error === "string" ? event.part.state.error : "Tool execution failed";
+				span.setStatus({
+					code: api.SpanStatusCode.ERROR,
+					message: err
+				});
+				span.recordException(new Error(err));
+			} else span.setStatus({ code: api.SpanStatusCode.OK });
+		} else if (event.type === "build_result" && !event.success) span.setStatus({
+			code: api.SpanStatusCode.ERROR,
+			message: "Build failed"
+		});
+		else if (event.type === "test_result" && !event.success) span.setStatus({
+			code: api.SpanStatusCode.ERROR,
+			message: "Tests failed"
+		});
+		else if (event.type === "custom" && event.name === "startup.phase" && event.data.status === "error") span.setStatus({
+			code: api.SpanStatusCode.ERROR,
+			message: typeof event.data.error === "string" ? event.data.error : "Startup phase failed"
+		});
+		else span.setStatus({ code: api.SpanStatusCode.OK });
+		span.end(endTime);
+	}
+	getEventStartTime(event) {
+		if (event.type === "custom" && event.name === "startup.phase") {
+			const durationMs = this.getStartupPhaseDurationMs(event);
+			if (typeof durationMs === "number") return new Date(event.timestamp.getTime() - durationMs);
+		}
+		return event.timestamp;
+	}
+	getEventEndTime(event) {
+		if (event.type === "custom" && event.name === "startup.phase") return event.timestamp;
+		if ("durationMs" in event && typeof event.durationMs === "number") return new Date(event.timestamp.getTime() + event.durationMs);
+		return event.timestamp;
+	}
+	getStartupPhaseDurationMs(event) {
+		return typeof event.data.durationMs === "number" ? event.data.durationMs : void 0;
+	}
+	/**
+	* Get span name for a trace event.
+	*/
+	getSpanName(event) {
+		switch (event.type) {
+			case "message.part.updated":
+				if (isToolPart(event.part)) return `tool.${event.part.tool}.${event.part.state.status}`;
+				if (isReasoningPart(event.part)) return "llm.reasoning";
+				if (isTextPart(event.part)) return "llm.text";
+				return "message.file";
+			case "message.updated": return "message.updated";
+			case "error": return `error.${event.category}`;
+			case "diagnostic": return `diagnostic.${event.language || "unknown"}`;
+			case "file_change": return `file.${event.changeType}`;
+			case "build_result": return `build.${event.success ? "success" : "failure"}`;
+			case "test_result": return `test.${event.success ? "success" : "failure"}`;
+			case "environment": return "environment.snapshot";
+			case "custom":
+				if (event.name === "startup.phase") return `startup.${typeof event.data.phase === "string" ? event.data.phase : "unknown"}`;
+				return `custom.${event.name}`;
+			default: return "unknown";
+		}
+	}
+	/**
+	* Get OTEL attributes for a trace event.
+	*/
+	getEventAttributes(event) {
+		const attrs = { "event.type": event.type };
+		switch (event.type) {
+			case "message.part.updated":
+				attrs["message.part.id"] = event.part.id;
+				attrs["message.part.type"] = event.part.type;
+				if (isToolPart(event.part)) {
+					attrs["tool.name"] = event.part.tool;
+					const status = event.part.state.status;
+					attrs["tool.status"] = status;
+					if (this.config.includePayloads && event.part.state.input) attrs["tool.input"] = JSON.stringify(event.part.state.input).slice(0, 4096);
+					if (this.config.includePayloads && status === "completed" && event.part.state.output !== void 0) attrs["tool.output"] = JSON.stringify(event.part.state.output).slice(0, 4096);
+					if (this.config.includePayloads && (status === "error" || status === "failed") && typeof event.part.state.error === "string") attrs["tool.error"] = event.part.state.error.slice(0, 4096);
+				} else if (isTextPart(event.part) || isReasoningPart(event.part)) {
+					attrs["message.part.text_length"] = event.part.text.length;
+					if (this.config.includePayloads) attrs["message.part.text"] = event.part.text.slice(0, 4096);
+				} else if (isFilePart(event.part)) {
+					attrs["file.name"] = event.part.filename;
+					if (event.part.mediaType) attrs["file.media_type"] = event.part.mediaType;
+				} else {
+					attrs["subtask.id"] = event.part.id;
+					attrs["subtask.session_id"] = event.part.sessionID;
+				}
+				break;
+			case "message.updated": {
+				const text = event.text ?? event.finalText;
+				if (typeof text === "string") {
+					attrs["message.text_length"] = text.length;
+					if (this.config.includePayloads) attrs["message.text"] = text.slice(0, 4096);
+				}
+				if (this.config.includePayloads && event.tokenUsage !== void 0) attrs["message.token_usage"] = JSON.stringify(event.tokenUsage).slice(0, 4096);
+				if (this.config.includePayloads && event.timing !== void 0) attrs["message.timing"] = JSON.stringify(event.timing).slice(0, 4096);
+				if (this.config.includePayloads && event.toolInvocations !== void 0) attrs["message.tool_invocations"] = JSON.stringify(event.toolInvocations).slice(0, 4096);
+				if (event.metadata) for (const key of GEN_AI_PROMOTED_KEYS) {
+					const value = event.metadata[key];
+					if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") attrs[key] = value;
+				}
+				if (this.config.includePayloads && event.metadata !== void 0) attrs["message.metadata"] = JSON.stringify(event.metadata).slice(0, 4096);
+				break;
+			}
+			case "error":
+				attrs["error.category"] = event.category;
+				attrs["error.message"] = event.message;
+				if (event.code) attrs["error.code"] = event.code;
+				if (event.source) attrs["error.source"] = event.source;
+				break;
+			case "diagnostic":
+				attrs["diagnostic.file"] = event.file;
+				if (event.language) attrs["diagnostic.language"] = event.language;
+				attrs["diagnostic.error_delta"] = event.errorDelta;
+				attrs["diagnostic.errors_after"] = event.afterSummary.errors;
+				attrs["diagnostic.warnings_after"] = event.afterSummary.warnings;
+				break;
+			case "file_change":
+				attrs["file.path"] = event.file;
+				attrs["file.change_type"] = event.changeType;
+				if (event.linesAdded) attrs["file.lines_added"] = event.linesAdded;
+				if (event.linesRemoved) attrs["file.lines_removed"] = event.linesRemoved;
+				break;
+			case "build_result":
+				attrs["build.success"] = event.success;
+				if (event.command) attrs["build.command"] = event.command;
+				if (event.durationMs) attrs["build.duration_ms"] = event.durationMs;
+				if (event.errorCount) attrs["build.error_count"] = event.errorCount;
+				if (event.warningCount) attrs["build.warning_count"] = event.warningCount;
+				break;
+			case "test_result":
+				attrs["test.success"] = event.success;
+				if (event.command) attrs["test.command"] = event.command;
+				if (event.durationMs) attrs["test.duration_ms"] = event.durationMs;
+				if (event.passed) attrs["test.passed"] = event.passed;
+				if (event.failed) attrs["test.failed"] = event.failed;
+				if (event.skipped) attrs["test.skipped"] = event.skipped;
+				break;
+			case "environment":
+				if (event.workingDir) attrs["env.working_dir"] = event.workingDir;
+				if (event.platform) attrs["env.platform"] = event.platform;
+				break;
+			case "custom":
+				attrs["custom.name"] = event.name;
+				if (event.name === "startup.phase") {
+					attrs["startup.id"] = typeof event.data.startupId === "string" ? event.data.startupId : void 0;
+					attrs["startup.phase"] = typeof event.data.phase === "string" ? event.data.phase : void 0;
+					attrs["startup.service"] = typeof event.data.service === "string" ? event.data.service : void 0;
+					attrs["startup.status"] = typeof event.data.status === "string" ? event.data.status : void 0;
+				}
+				for (const [key, value] of Object.entries(event.data)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") attrs[`custom.data.${key}`] = value;
+				break;
+		}
+		return attrs;
+	}
+	/**
+	* Flatten metadata object into span attributes
+	*/
+	flattenMetadata(metadata, prefix = "metadata") {
+		const attrs = {};
+		for (const [key, value] of Object.entries(metadata)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") attrs[`${prefix}.${key}`] = value;
+		return attrs;
+	}
+	/** Narrow an opaque telemetry `data.trace` to an ExecutionTrace. */
+	isExecutionTrace(value) {
+		return typeof value === "object" && value !== null && "scope" in value && "events" in value && Array.isArray(value.events);
+	}
+	async flush() {}
+	async close() {}
+};
+/**
+* Create an OTEL sink that uses the global tracer.
+*
+* The OTEL SDK must be initialized separately before using this sink.
+*/
+function createOtelSink(config) {
+	return new OtelTelemetrySink(config);
+}
+/**
+* Create an OTEL sink from environment variables.
+*
+* Returns a sink that uses the global tracer (which should be initialized
+* separately via NodeSDK with LangfuseSpanProcessor or OTLPTraceExporter).
+*/
+function createOtelSinkFromEnv() {
+	const enabled = process.env.TELEMETRY_ENABLED === "true";
+	const hasLangfuse = process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY;
+	const hasOtlp = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	if (!enabled || !hasLangfuse && !hasOtlp) return null;
+	return new OtelTelemetrySink({
+		serviceName: process.env.OTEL_SERVICE_NAME || "orchestrator",
+		includePayloads: process.env.OTEL_INCLUDE_PAYLOADS === "true"
+	});
+}
+//#endregion
+//#region src/sinks.ts
+var HttpTelemetrySink = class {
+	name = "http";
+	endpoint;
+	headers;
+	fetchFn;
+	timeout;
+	pendingRequests = [];
+	constructor(config) {
+		this.endpoint = config.endpoint;
+		this.headers = {
+			"Content-Type": "application/json",
+			...config.headers
+		};
+		this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+		this.timeout = config.timeout ?? 3e4;
+	}
+	async send(events) {
+		const request = this.fetchFn(this.endpoint, {
+			method: "POST",
+			headers: this.headers,
+			body: JSON.stringify({ events }),
+			signal: AbortSignal.timeout(this.timeout)
+		}).then((res) => {
+			if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+		});
+		this.pendingRequests.push(request);
+		try {
+			await request;
+		} finally {
+			this.pendingRequests = this.pendingRequests.filter((r) => r !== request);
+		}
+	}
+	async flush() {
+		await Promise.all(this.pendingRequests);
+	}
+	async close() {
+		await this.flush();
+	}
+};
+var ConsoleTelemetrySink = class {
+	name = "console";
+	prefix;
+	logLevel;
+	formatJson;
+	constructor(config) {
+		this.prefix = config?.prefix ?? "[telemetry]";
+		this.logLevel = config?.logLevel ?? "debug";
+		this.formatJson = config?.formatJson ?? true;
+	}
+	async send(events) {
+		for (const event of events) {
+			const message = this.formatJson ? JSON.stringify(event, null, 2) : `${event.type}:${event.name} ${JSON.stringify(event.data)}`;
+			console[this.logLevel](`${this.prefix} ${message}`);
+		}
+	}
+	async flush() {}
+	async close() {}
+};
+var TestTelemetrySink = class {
+	name = "test";
+	events = [];
+	async send(events) {
+		this.events.push(...events);
+	}
+	async flush() {}
+	async close() {}
+	clear() {
+		this.events.length = 0;
+	}
+	getEvents() {
+		return [...this.events];
+	}
+	getEventsByType(type) {
+		return this.events.filter((e) => e.type === type);
+	}
+	getEventsByName(name) {
+		return this.events.filter((e) => e.name === name);
+	}
+};
+var MultiTelemetrySink = class {
+	name = "multi";
+	sinks;
+	constructor(sinks) {
+		this.sinks = sinks;
+	}
+	async send(events) {
+		await Promise.all(this.sinks.map((sink) => sink.send(events)));
+	}
+	async flush() {
+		await Promise.all(this.sinks.map((sink) => sink.flush()));
+	}
+	async close() {
+		await Promise.all(this.sinks.map((sink) => sink.close()));
+	}
+};
+function createHttpSink(config) {
+	return new HttpTelemetrySink(config);
+}
+function createConsoleSink(config) {
+	return new ConsoleTelemetrySink(config);
+}
+function createTestSink() {
+	return new TestTelemetrySink();
+}
+//#endregion
+//#region src/sse-parser.ts
+/**
+* SSE Event Parser
+*
+* Converts SSE stream events to typed TraceEvents.
+* Used by both orchestrator and simulation to ensure consistent event capture.
+*
+* message.part.updated events are passed through directly without transformation.
+* This preserves full fidelity to what OpenCode outputs.
+*/
+const parseSSEData = parseSSEData$1;
+/** Valid signals from SSE status events */
+const VALID_SIGNALS = [
+	"build_passed",
+	"build_failed",
+	"tests_passed",
+	"tests_failed",
+	"lint_passed",
+	"lint_failed",
+	"user_approved",
+	"user_rejected",
+	"task_completed",
+	"task_abandoned",
+	"runtime_error",
+	"timeout"
+];
+/**
+* Provider event shapes that carry a tool-invocation payload either at
+* the top level or under one of the well-known wrappers. Recognized here
+* (and not in the consumer) so trace events look identical regardless of
+* which provider emitted the call.
+*/
+const TOOL_INVOCATION_TYPES = new Set([
+	"tool-invocation",
+	`tool_call`,
+	"computer-use",
+	"computer_call"
+]);
+/**
+* Best-effort: lift a raw tool-invocation event into a canonical
+* `message.part.updated` event with a `ToolPart`. Returns null for
+* payloads we cannot recognize, which lets the caller fall through to
+* a `custom` trace event rather than silently misclassifying.
+*
+* Wire contract — what shapes are expected here:
+*
+*   This normalizer runs at the trace-event boundary, AFTER provider
+*   adapters have done their own normalization. Adapters
+*   (sdk-provider-opencode, sdk-provider-amp, sdk-provider-claude-code,
+*   etc.) translate provider-native events into our internal
+*   AgentStreamEvent shape — typically wrapping tool invocations
+*   under `toolInvocation`/`tool_invocation`/`computerUse`/
+*   `computer_use`, with `type` set to one of `TOOL_INVOCATION_TYPES`.
+*
+*   Provider-native shapes that adapters are expected to unwrap:
+*
+*     OpenAI Responses / Chat Completions:
+*       `{id, type: "function", function: {name, arguments}}` →
+*       adapter wraps into an internal tool-invocation event with `toolInvocation: {
+*       toolCallId: id, toolName: function.name, args: function.arguments}}`
+*
+*     Anthropic tool_use blocks:
+*       `{type: "tool_use", id, name, input}` →
+*       adapter wraps into an internal tool-invocation event with `toolInvocation`.
+*
+*   The flat-with-`id` fallback (`source.id` in the callId chain) is
+*   a defensive safety net for cases where an adapter forwards the
+*   provider's flat shape verbatim. It is NOT a substitute for
+*   adapter-side normalization — the literal OpenAI
+*   `{type: "function", function: {...}}` wrapper is NOT recognized
+*   here because `"function"` is intentionally not in
+*   TOOL_INVOCATION_TYPES (the word collides with too many
+*   non-tool-call uses of `function` as a top-level key).
+*/
+function normalizeRawToolInvocation(event, timestamp) {
+	const top = event;
+	const wrapped = top.toolInvocation ?? top.tool_invocation ?? top.computerUse ?? top.computer_use;
+	const innerType = typeof top.type === "string" ? top.type : void 0;
+	const sourceType = typeof top.event === "object" && top.event !== null ? top.event.type : void 0;
+	const isToolType = innerType && TOOL_INVOCATION_TYPES.has(innerType) || sourceType && TOOL_INVOCATION_TYPES.has(sourceType);
+	if (!wrapped && !isToolType) return null;
+	const source = wrapped ?? top;
+	const isComputerUse = innerType === "computer-use" || innerType === "computer_call" || sourceType === "computer-use" || sourceType === "computer_call";
+	const callId = String(source.toolCallId ?? source.tool_call_id ?? source.callId ?? source.callID ?? source.id ?? "");
+	const baseName = String(source.toolName ?? source.tool_name ?? source.name ?? "");
+	const toolName = isComputerUse ? `computer-use:${source.action?.type || "action"}` : baseName;
+	if (!callId || !toolName) return null;
+	const stateObj = source.state ?? void 0;
+	const input = source.args ?? source.arguments ?? source.input ?? stateObj?.input ?? {};
+	const output = source.result ?? source.output ?? stateObj?.output;
+	const errorMsg = typeof source.error === "string" ? source.error : typeof stateObj?.error === "string" ? stateObj.error : void 0;
+	const stateStatus = typeof stateObj?.status === "string" ? stateObj.status : void 0;
+	const explicitStatus = typeof source.status === "string" ? source.status : void 0;
+	const status = stateStatus ?? explicitStatus ?? (output !== void 0 ? "completed" : "running");
+	let toolState;
+	switch (status) {
+		case "completed":
+			toolState = {
+				status: "completed",
+				input: input ?? {},
+				output: output ?? null
+			};
+			break;
+		case "queued":
+		case "pending":
+			toolState = {
+				status: "pending",
+				input: input ?? {}
+			};
+			break;
+		case "running":
+		case "in_progress":
+			toolState = {
+				status: "running",
+				input: input ?? {}
+			};
+			break;
+		case "error":
+		case "failed":
+			toolState = {
+				status,
+				input: input ?? {},
+				output,
+				error: errorMsg
+			};
+			break;
+		default: toolState = {
+			status: "running",
+			input: input ?? {}
+		};
+	}
+	return {
+		type: "message.part.updated",
+		part: {
+			id: callId,
+			sessionID: "",
+			messageID: "",
+			type: "tool",
+			callID: callId,
+			tool: toolName,
+			state: toolState
+		},
+		timestamp
+	};
+}
+/**
+* Convert SSE event data to a typed TraceEvent.
+* Returns null for events that should be skipped (heartbeats, status-only, etc.)
+*
+* message.part.updated events are passed through directly - no transformation.
+* This preserves full fidelity to what OpenCode outputs.
+*
+* `raw` events that carry a recognized tool-invocation payload are
+* normalized into the same `message.part.updated` shape (with a
+* `ToolPart`) so consumers don't need to reach into provider-specific
+* raw shapes to render tool calls. Unrecognized raw events fall
+* through to a `custom` trace event.
+*/
+function sseToTraceEvent(event) {
+	const timestamp = /* @__PURE__ */ new Date();
+	if (event.type === "raw" || typeof event.type === "string" && TOOL_INVOCATION_TYPES.has(event.type)) {
+		const normalized = normalizeRawToolInvocation(event, timestamp);
+		if (normalized) {
+			if (normalized.part.state?.status === "pending") return null;
+			return normalized;
+		}
+		const customName = typeof event.type === "string" ? event.type : "raw";
+		return {
+			type: "custom",
+			timestamp,
+			name: customName,
+			data: {
+				eventType: customName,
+				...event
+			}
+		};
+	}
+	switch (event.type) {
+		case "message.part.updated": {
+			const part = event.part;
+			if (!part) return null;
+			if (part.type === "tool") {
+				const status = part.state?.status;
+				if (status === "pending" || status === "queued") return null;
+			}
+			return {
+				type: "message.part.updated",
+				part,
+				timestamp,
+				delta: event.delta,
+				_meta: event._meta
+			};
+		}
+		case "error": return {
+			type: "error",
+			timestamp,
+			category: "runtime",
+			message: String(event.message || event.error || "Unknown error"),
+			code: typeof event.code === "string" ? event.code : void 0
+		};
+		case "status": return null;
+		case "result": {
+			const finalText = typeof event.finalText === "string" ? event.finalText : typeof event.text === "string" ? event.text : void 0;
+			return {
+				type: "message.updated",
+				timestamp,
+				text: finalText,
+				finalText,
+				tokenUsage: event.tokenUsage,
+				timing: event.timing,
+				toolInvocations: event.toolInvocations,
+				metadata: event.metadata
+			};
+		}
+		case "done": return null;
+		default:
+			if (event.type && event.type !== "heartbeat") return {
+				type: "custom",
+				timestamp,
+				name: event.type,
+				data: {
+					eventType: event.type,
+					...event
+				}
+			};
+			return null;
+	}
+}
+/**
+* Extract a signal from an SSE event if present.
+*/
+function sseToSignal(event) {
+	if (event.type === "status" && typeof event.status === "string") {
+		if (VALID_SIGNALS.includes(event.status)) return {
+			signal: event.status,
+			timestamp: /* @__PURE__ */ new Date()
+		};
+	}
+	return null;
+}
+/**
+* Check if an SSE event indicates completion (success or failure).
+*/
+function isCompletionEvent(event) {
+	if (event.type === "done" || event.type === "result") return {
+		complete: true,
+		success: !("success" in event && event.success === false)
+	};
+	if (event.type === "error") return {
+		complete: true,
+		success: false
+	};
+	return {
+		complete: false,
+		success: false
+	};
+}
+//#endregion
+//#region src/trace-collector.ts
+const randomUUID = () => {
+	const webCrypto = globalThis.crypto;
+	if (webCrypto?.randomUUID) return webCrypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+		const r = Math.random() * 16 | 0;
+		return (ch === "x" ? r : r & 3 | 8).toString(16);
+	});
+};
+var TraceCollector = class {
+	sink;
+	config;
+	activeTraces = /* @__PURE__ */ new Map();
+	completedTraces = [];
+	flushTimer;
+	sequence = 0;
+	constructor(config) {
+		this.sink = config.sink;
+		this.config = {
+			maxBufferSize: config.maxBufferSize ?? 100,
+			flushIntervalMs: config.flushIntervalMs ?? 0,
+			defaultScope: config.defaultScope
+		};
+		if (this.config.flushIntervalMs > 0) this.flushTimer = setInterval(() => {
+			this.flush().catch(() => {});
+		}, this.config.flushIntervalMs);
+	}
+	/** Start tracking a new execution */
+	startTrace(task, scope, metadata) {
+		const traceId = `trace_${randomUUID()}`;
+		const startedAt = /* @__PURE__ */ new Date();
+		const activeTrace = {
+			id: traceId,
+			scope: scope ?? this.config.defaultScope ?? {},
+			task,
+			events: [],
+			signals: [],
+			startedAt,
+			metadata
+		};
+		this.activeTraces.set(traceId, activeTrace);
+		return {
+			traceId,
+			startedAt,
+			addEvent: (event) => {
+				const trace = this.activeTraces.get(traceId);
+				if (trace) trace.events.push({
+					...event,
+					timestamp: /* @__PURE__ */ new Date()
+				});
+			},
+			addSignal: (signal, signalMeta) => {
+				const trace = this.activeTraces.get(traceId);
+				if (trace) trace.signals.push({
+					signal,
+					timestamp: /* @__PURE__ */ new Date(),
+					metadata: signalMeta
+				});
+			},
+			complete: (completeMeta) => {
+				return this.completeTrace(traceId, "success", completeMeta);
+			},
+			fail: (error, failMeta) => {
+				const trace = this.activeTraces.get(traceId);
+				if (trace) {
+					const errorMsg = error instanceof Error ? error.message : error;
+					trace.events.push({
+						type: "error",
+						timestamp: /* @__PURE__ */ new Date(),
+						category: "runtime",
+						message: errorMsg,
+						stack: error instanceof Error ? error.stack : void 0
+					});
+					trace.signals.push({
+						signal: "runtime_error",
+						timestamp: /* @__PURE__ */ new Date()
+					});
+				}
+				return this.completeTrace(traceId, "failure", failMeta);
+			},
+			abandon: () => {
+				return this.completeTrace(traceId, "unknown", { abandoned: true });
+			}
+		};
+	}
+	/** Convenience: track a complete execution with a wrapper function */
+	async track(task, fn, options) {
+		const ctx = this.startTrace(task, options?.scope, options?.metadata);
+		try {
+			return {
+				result: await fn(ctx),
+				trace: ctx.complete()
+			};
+		} catch (error) {
+			ctx.fail(error instanceof Error ? error : String(error));
+			throw error;
+		}
+	}
+	/** Flush completed traces to sink */
+	async flush() {
+		if (this.completedTraces.length === 0) return;
+		const events = this.completedTraces.map((trace) => ({
+			id: `evt_${randomUUID()}`,
+			type: "agent_execution",
+			name: "execution_trace",
+			projectRef: trace.scope.projectRef,
+			sessionId: trace.scope.sessionId,
+			userId: trace.scope.userId,
+			data: {
+				traceId: trace.id,
+				task: trace.task,
+				outcome: trace.outcome,
+				eventCount: trace.events.length,
+				signalCount: trace.signals.length,
+				durationMs: trace.completedAt ? trace.completedAt.getTime() - trace.startedAt.getTime() : void 0,
+				trace
+			},
+			timestamp: trace.completedAt ?? /* @__PURE__ */ new Date(),
+			sequence: this.sequence++
+		}));
+		await this.sink.send(events);
+		this.completedTraces = [];
+	}
+	/** Get count of pending traces */
+	getPendingCount() {
+		return this.completedTraces.length;
+	}
+	/** Get active trace count */
+	getActiveCount() {
+		return this.activeTraces.size;
+	}
+	/** Shutdown collector */
+	async shutdown() {
+		if (this.flushTimer) clearInterval(this.flushTimer);
+		await this.flush();
+		await this.sink.flush();
+		await this.sink.close();
+	}
+	completeTrace(traceId, outcome, metadata) {
+		const active = this.activeTraces.get(traceId);
+		if (!active) throw new Error(`Trace not found: ${traceId}`);
+		this.activeTraces.delete(traceId);
+		const completedTrace = {
+			id: active.id,
+			scope: active.scope,
+			task: active.task,
+			events: active.events,
+			signals: active.signals,
+			outcome: this.classifyOutcome(active.signals, outcome),
+			startedAt: active.startedAt,
+			completedAt: /* @__PURE__ */ new Date(),
+			metadata: {
+				...active.metadata,
+				...metadata
+			}
+		};
+		this.completedTraces.push(completedTrace);
+		if (this.completedTraces.length >= this.config.maxBufferSize) this.flush().catch(() => {});
+		return completedTrace;
+	}
+	classifyOutcome(signals, defaultOutcome) {
+		const signalSet = new Set(signals.map((s) => s.signal));
+		if (signalSet.has("task_completed")) {
+			if (signalSet.has("tests_passed") || signalSet.has("build_passed") || signalSet.has("user_approved")) return "success";
+			return "partial";
+		}
+		if (signalSet.has("runtime_error") || signalSet.has("timeout") || signalSet.has("tests_failed") || signalSet.has("build_failed") || signalSet.has("user_rejected")) return "failure";
+		if (signalSet.has("task_abandoned")) return "unknown";
+		return defaultOutcome;
+	}
+};
+function createTraceCollector(config) {
+	return new TraceCollector(config);
+}
+//#endregion
+//#region src/tracker.ts
+const DEFAULT_CONFIG$1 = {
+	enabled: true,
+	flushIntervalMs: 3e4,
+	maxBatchSize: 100,
+	maxQueueSize: 1e3,
+	sampleRate: 1,
+	excludePatterns: [],
+	includeMetadata: true,
+	persistOffline: true
+};
+var TelemetryTracker = class {
+	config;
+	sinks = [];
+	queue = [];
+	storage;
+	sequence = 0;
+	flushTimer;
+	sessionStartTime;
+	isFlushing = false;
+	constructor(config, storage) {
+		this.config = {
+			...DEFAULT_CONFIG$1,
+			...config
+		};
+		this.storage = storage;
+		if (this.config.enabled && this.config.flushIntervalMs > 0) this.startFlushTimer();
+	}
+	addSink(sink) {
+		this.sinks.push(sink);
+		return this;
+	}
+	removeSink(name) {
+		const index = this.sinks.findIndex((s) => s.name === name);
+		if (index !== -1) this.sinks.splice(index, 1);
+		return this;
+	}
+	startSession(metadata) {
+		const sessionId = this.config.sessionId ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+		this.sessionStartTime = /* @__PURE__ */ new Date();
+		this.track("session_start", "session.started", {
+			...metadata,
+			sessionId,
+			startTime: this.sessionStartTime.toISOString()
+		});
+		return sessionId;
+	}
+	endSession(metadata) {
+		const duration = this.sessionStartTime ? Date.now() - this.sessionStartTime.getTime() : 0;
+		this.track("session_end", "session.ended", {
+			...metadata,
+			durationMs: duration,
+			eventCount: this.sequence
+		});
+		this.flush();
+	}
+	track(type, name, data = {}) {
+		if (!this.config.enabled) return;
+		if (!this.shouldSample()) return;
+		if (this.isExcluded(name)) return;
+		const event = {
+			id: `evt-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+			type,
+			name,
+			projectRef: this.config.projectRef,
+			sessionId: this.config.sessionId,
+			userId: this.config.userId,
+			data: this.config.includeMetadata ? this.enrichData(data) : data,
+			timestamp: /* @__PURE__ */ new Date(),
+			sequence: ++this.sequence
+		};
+		this.enqueue(event);
+	}
+	trackPerformance(metric) {
+		this.track("performance", `perf.${metric.name}`, {
+			value: metric.value,
+			unit: metric.unit,
+			tags: metric.tags
+		});
+	}
+	trackError(error, context) {
+		const errorData = error instanceof Error ? {
+			message: error.message,
+			name: error.name,
+			stack: error.stack
+		} : { message: error };
+		this.track("error", "error.occurred", {
+			...errorData,
+			...context
+		});
+	}
+	trackApiRequest(method, path, status, durationMs, metadata) {
+		this.track("api_request", `api.${method.toLowerCase()}.${path}`, {
+			method,
+			path,
+			status,
+			durationMs,
+			...metadata
+		});
+	}
+	trackAgentExecution(identifier, executionId, durationMs, success, metadata) {
+		this.track("agent_execution", `agent.${identifier}`, {
+			identifier,
+			executionId,
+			durationMs,
+			success,
+			...metadata
+		});
+	}
+	async flush() {
+		if (this.isFlushing || this.queue.length === 0) return;
+		this.isFlushing = true;
+		try {
+			const events = this.queue.splice(0, this.config.maxBatchSize);
+			await Promise.all(this.sinks.map((sink) => sink.send(events)));
+			if (this.config.persistOffline && this.storage) await this.clearPersistedEvents(events.map((e) => e.id));
+		} catch (_error) {
+			if (this.config.persistOffline && this.storage) await this.persistEvents(this.queue);
+		} finally {
+			this.isFlushing = false;
+		}
+	}
+	async close() {
+		this.stopFlushTimer();
+		await this.flush();
+		await Promise.all(this.sinks.map((sink) => sink.close()));
+	}
+	getQueueSize() {
+		return this.queue.length;
+	}
+	isEnabled() {
+		return this.config.enabled;
+	}
+	enable() {
+		this.config.enabled = true;
+		this.startFlushTimer();
+	}
+	disable() {
+		this.config.enabled = false;
+		this.stopFlushTimer();
+	}
+	enqueue(event) {
+		if (this.queue.length >= this.config.maxQueueSize) this.queue.shift();
+		this.queue.push(event);
+		if (this.queue.length >= this.config.maxBatchSize) this.flush();
+		if (this.config.persistOffline && this.storage) this.persistEvent(event);
+	}
+	shouldSample() {
+		return Math.random() < this.config.sampleRate;
+	}
+	isExcluded(name) {
+		return this.config.excludePatterns.some((pattern) => {
+			if (pattern.includes("*")) return new RegExp(`^${pattern.replace(/\*/g, ".*").replace(/\?/g, ".")}$`).test(name);
+			return name === pattern;
+		});
+	}
+	enrichData(data) {
+		return {
+			...data,
+			_meta: {
+				timestamp: Date.now(),
+				platform: typeof navigator !== "undefined" ? navigator.userAgent : "node",
+				timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+			}
+		};
+	}
+	startFlushTimer() {
+		if (this.flushTimer) return;
+		this.flushTimer = setInterval(() => this.flush(), this.config.flushIntervalMs);
+	}
+	stopFlushTimer() {
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = void 0;
+		}
+	}
+	async persistEvent(event) {
+		if (!this.storage) return;
+		const key = `telemetry:${event.id}`;
+		await this.storage.set(key, event);
+	}
+	async persistEvents(events) {
+		if (!this.storage) return;
+		await Promise.all(events.map((e) => this.persistEvent(e)));
+	}
+	async clearPersistedEvents(ids) {
+		if (!this.storage) return;
+		await Promise.all(ids.map((id) => this.storage?.delete(`telemetry:${id}`)));
+	}
+	async loadPersistedEvents() {
+		if (!this.storage) return [];
+		const telemetryKeys = (await this.storage.keys()).filter((k) => k.startsWith("telemetry:"));
+		const events = [];
+		for (const key of telemetryKeys) {
+			const event = await this.storage.get(key);
+			if (event) events.push(event);
+		}
+		return events.sort((a, b) => a.sequence - b.sequence);
+	}
+};
+function createTelemetryTracker(config, storage) {
+	return new TelemetryTracker(config, storage);
+}
+//#endregion
+//#region src/usage.ts
+const DEFAULT_CONFIG = {
+	autoTrack: true,
+	trackApiCalls: true,
+	trackAgentExecutions: true,
+	trackErrors: true,
+	batchSize: 50,
+	flushIntervalMs: 3e4
+};
+const OPERATION_COSTS = {
+	"api.get": .001,
+	"api.post": .002,
+	"api.put": .002,
+	"api.delete": .001,
+	"agent.execution": .01,
+	"agent.streaming": .015,
+	"token.input": 1e-5,
+	"token.output": 3e-5,
+	default: .001
+};
+var UsageTracker = class {
+	config;
+	provider;
+	storage;
+	queue = [];
+	flushTimer;
+	isFlushing = false;
+	sessionMetrics = {
+		totalCredits: 0,
+		totalOperations: 0,
+		totalDurationMs: 0,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		operationCounts: /* @__PURE__ */ new Map(),
+		startTime: Date.now()
+	};
+	constructor(config, provider, storage) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+		this.provider = provider;
+		this.storage = storage;
+		if (this.config.flushIntervalMs > 0) this.startFlushTimer();
+	}
+	recordApiCall(metric) {
+		if (!this.config.trackApiCalls) return;
+		const operation = `api.${metric.method.toLowerCase()}`;
+		const credits = this.calculateCost(operation, {
+			durationMs: metric.durationMs,
+			requestSize: metric.requestSize,
+			responseSize: metric.responseSize
+		});
+		this.record({
+			projectRef: this.config.projectRef,
+			userId: this.config.userId,
+			operation,
+			credits,
+			durationMs: metric.durationMs,
+			metadata: {
+				path: metric.path,
+				status: metric.status,
+				requestSize: metric.requestSize,
+				responseSize: metric.responseSize,
+				error: metric.error
+			}
+		});
+	}
+	recordAgentExecution(metric) {
+		if (!this.config.trackAgentExecutions) return;
+		const operation = "agent.execution";
+		const tokenCost = (metric.inputTokens ?? 0) * OPERATION_COSTS["token.input"] + (metric.outputTokens ?? 0) * OPERATION_COSTS["token.output"];
+		const credits = this.calculateCost(operation, { durationMs: metric.durationMs }) + tokenCost;
+		this.record({
+			projectRef: metric.projectRef,
+			userId: this.config.userId,
+			operation,
+			credits,
+			durationMs: metric.durationMs,
+			inputTokens: metric.inputTokens,
+			outputTokens: metric.outputTokens,
+			metadata: {
+				identifier: metric.identifier,
+				executionId: metric.executionId,
+				toolCalls: metric.toolCalls,
+				success: metric.success,
+				error: metric.error
+			}
+		});
+	}
+	recordError(error, operation) {
+		if (!this.config.trackErrors) return;
+		this.record({
+			projectRef: this.config.projectRef,
+			userId: this.config.userId,
+			operation: `error.${operation}`,
+			credits: 0,
+			metadata: {
+				error: error instanceof Error ? error.message : error,
+				stack: error instanceof Error ? error.stack : void 0
+			}
+		});
+	}
+	record(usage) {
+		this.queue.push(usage);
+		this.sessionMetrics.totalCredits += usage.credits;
+		this.sessionMetrics.totalOperations++;
+		this.sessionMetrics.totalDurationMs += usage.durationMs ?? 0;
+		this.sessionMetrics.totalInputTokens += usage.inputTokens ?? 0;
+		this.sessionMetrics.totalOutputTokens += usage.outputTokens ?? 0;
+		const count = this.sessionMetrics.operationCounts.get(usage.operation) ?? 0;
+		this.sessionMetrics.operationCounts.set(usage.operation, count + 1);
+		if (this.queue.length >= this.config.batchSize) this.flush();
+	}
+	async flush() {
+		if (this.isFlushing || this.queue.length === 0) return;
+		this.isFlushing = true;
+		const records = this.queue.splice(0, this.config.batchSize);
+		const providerFailed = /* @__PURE__ */ new Set();
+		const providerDone = /* @__PURE__ */ new Set();
+		try {
+			if (this.provider) {
+				const results = await Promise.allSettled(records.map((r) => this.provider?.recordUsage(r)));
+				for (let i = 0; i < records.length; i++) if (results[i].status === "rejected") providerFailed.add(records[i]);
+				else providerDone.add(records[i]);
+				if (providerFailed.size > 0) this.queue.unshift(...providerFailed);
+			}
+			if (this.storage) {
+				const toPersist = providerFailed.size > 0 ? records.filter((r) => !providerFailed.has(r)) : records;
+				if (toPersist.length > 0) await this.persistRecords(toPersist);
+			}
+		} catch (error) {
+			const firstFailed = typeof error?.firstFailedIndex === "number" ? error.firstFailedIndex : 0;
+			const unwritten = records.slice(firstFailed);
+			if (providerDone.size > 0) console.warn(`[usage-tracker] storage persistence failed for ${providerDone.size} provider-accepted records — local audit trail incomplete`, error instanceof Error ? error.message : String(error));
+			const unhandled = unwritten.filter((r) => !providerFailed.has(r) && !providerDone.has(r));
+			if (unhandled.length > 0) this.queue.unshift(...unhandled);
+		} finally {
+			this.isFlushing = false;
+		}
+	}
+	async getUsage(options) {
+		if (this.provider) return this.provider.getUsage({
+			projectRef: this.config.projectRef,
+			...options
+		});
+		return this.loadPersistedRecords(options);
+	}
+	async getSummary(period = "day") {
+		if (this.provider) return this.provider.getSummary(this.config.projectRef, period);
+		return this.generateLocalSummary(period);
+	}
+	getSessionMetrics() {
+		return {
+			totalCredits: this.sessionMetrics.totalCredits,
+			totalOperations: this.sessionMetrics.totalOperations,
+			totalDurationMs: this.sessionMetrics.totalDurationMs,
+			totalInputTokens: this.sessionMetrics.totalInputTokens,
+			totalOutputTokens: this.sessionMetrics.totalOutputTokens,
+			operationBreakdown: Object.fromEntries(this.sessionMetrics.operationCounts),
+			sessionDurationMs: Date.now() - this.sessionMetrics.startTime
+		};
+	}
+	resetSessionMetrics() {
+		this.sessionMetrics = {
+			totalCredits: 0,
+			totalOperations: 0,
+			totalDurationMs: 0,
+			totalInputTokens: 0,
+			totalOutputTokens: 0,
+			operationCounts: /* @__PURE__ */ new Map(),
+			startTime: Date.now()
+		};
+	}
+	async close() {
+		this.stopFlushTimer();
+		await this.flush();
+	}
+	calculateCost(operation, factors) {
+		let cost = OPERATION_COSTS[operation] ?? OPERATION_COSTS.default;
+		if (factors.durationMs) cost += factors.durationMs / 1e3 * .001;
+		if (factors.requestSize) cost += factors.requestSize / 1024 * 1e-4;
+		if (factors.responseSize) cost += factors.responseSize / 1024 * 1e-4;
+		return Math.round(cost * 1e5) / 1e5;
+	}
+	async persistRecords(records) {
+		if (!this.storage) return;
+		const timestamp = Date.now();
+		for (let i = 0; i < records.length; i++) {
+			const record = records[i];
+			const id = `usage-${timestamp}-${i}`;
+			try {
+				await this.storage.set(`usage:${id}`, {
+					...record,
+					id,
+					timestamp: /* @__PURE__ */ new Date()
+				});
+			} catch (err) {
+				throw Object.assign(err instanceof Error ? err : new Error(String(err)), { firstFailedIndex: i });
+			}
+		}
+	}
+	async loadPersistedRecords(options) {
+		if (!this.storage) return [];
+		const usageKeys = (await this.storage.keys()).filter((k) => k.startsWith("usage:"));
+		const records = [];
+		for (const key of usageKeys) {
+			const record = await this.storage.get(key);
+			if (!record) continue;
+			if (options?.since && record.timestamp < options.since) continue;
+			if (options?.until && record.timestamp > options.until) continue;
+			records.push(record);
+		}
+		records.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+		return options?.limit ? records.slice(0, options.limit) : records;
+	}
+	async generateLocalSummary(period) {
+		const now = /* @__PURE__ */ new Date();
+		const periodStart = this.getPeriodStart(now, period);
+		const records = await this.loadPersistedRecords({
+			since: periodStart,
+			until: now
+		});
+		const operationBreakdown = {};
+		let totalCredits = 0;
+		let totalDurationMs = 0;
+		let totalInputTokens = 0;
+		let totalOutputTokens = 0;
+		for (const record of records) {
+			totalCredits += record.credits;
+			totalDurationMs += record.durationMs ?? 0;
+			totalInputTokens += record.inputTokens ?? 0;
+			totalOutputTokens += record.outputTokens ?? 0;
+			operationBreakdown[record.operation] = (operationBreakdown[record.operation] ?? 0) + 1;
+		}
+		return {
+			projectRef: this.config.projectRef,
+			period,
+			periodStart,
+			periodEnd: now,
+			totalCredits,
+			totalOperations: records.length,
+			totalDurationMs,
+			totalInputTokens,
+			totalOutputTokens,
+			operationBreakdown
+		};
+	}
+	getPeriodStart(now, period) {
+		const start = new Date(now);
+		switch (period) {
+			case "hour":
+				start.setMinutes(0, 0, 0);
+				break;
+			case "day":
+				start.setHours(0, 0, 0, 0);
+				break;
+			case "week":
+				start.setDate(start.getDate() - start.getDay());
+				start.setHours(0, 0, 0, 0);
+				break;
+			case "month":
+				start.setDate(1);
+				start.setHours(0, 0, 0, 0);
+				break;
+		}
+		return start;
+	}
+	startFlushTimer() {
+		if (this.flushTimer) return;
+		this.flushTimer = setInterval(() => this.flush(), this.config.flushIntervalMs);
+	}
+	stopFlushTimer() {
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = void 0;
+		}
+	}
+};
+function createUsageInterceptor(tracker) {
+	return {
+		onRequest(ctx) {
+			return ctx;
+		},
+		onResponse(ctx) {
+			const durationMs = Date.now() - ctx.startedAt;
+			tracker.recordApiCall({
+				path: new URL(ctx.request.url).pathname,
+				method: ctx.request.method,
+				status: ctx.response.status,
+				durationMs,
+				timestamp: /* @__PURE__ */ new Date()
+			});
+		},
+		onError(ctx) {
+			const durationMs = Date.now() - ctx.startedAt;
+			tracker.recordApiCall({
+				path: new URL(ctx.request.url).pathname,
+				method: ctx.request.method,
+				status: 0,
+				durationMs,
+				error: ctx.error.message,
+				timestamp: /* @__PURE__ */ new Date()
+			});
+		}
+	};
+}
+function createUsageTracker(config, provider, storage) {
+	return new UsageTracker(config, provider, storage);
+}
+//#endregion
+export { AdapterRegistry, ConsoleTelemetrySink, CreditTracker, GEN_AI_CONVERSATION_ID, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OPERATION_NAME, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, HttpTelemetrySink, LangfuseSink, MemoryCreditProvider, MultiTelemetrySink, OtelTelemetrySink, PROVISION_TRACE_ID_HEADER, PTID_PREFIX, SSEChunkParser, SpanRecorder, StreamUsageExtractor, TOKEN_USAGE_COST_KEYS, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, TelemetryTracker, TestTelemetrySink, TraceCollector, UsageTracker, addTokenUsage, consumeSSEStream, createConsoleSink, createCreditTracker, createEmptyContext, createHttpSink, createJsonAdapter, createLangfuseSinkFromEnv, createOtelSink, createOtelSinkFromEnv, createStreamUsageExtractor, createTelemetryTracker, createTestSink, createTraceCollector, createUsageCallback, createUsageInterceptor, createUsageTracker, firstTokenCount, firstUsageCostUsd, genAiUsageAttributes, getDefaultRegistry, initOtelProvider, initializeDefaultAdapters, isAdoptablePtid, isBuildResultEvent, isCompletionEvent, isCustomEvent, isDiagnosticEvent, isEnvironmentEvent, isErrorEvent, isFileChangeEvent, isFilePart, isMessagePartUpdatedEvent, isMessageUpdatedEvent, isReasoningPart, isTestResultEvent, isTextPart, isToolPart, jsonAdapter, mintPtid, monotonicNs, parseMetadataBlob, parseSSEData, parseSSEStream, parseServerTiming, readOrMintPtid, readTokenCostUsd, readTokenUsage, resetDefaultRegistry, shutdownOtelProvider, spanDurationMs, sseToSignal, sseToTraceEvent, tokenCount, tokenUsageSource };
+
+//# sourceMappingURL=index.mjs.map