@tangle-network/agent-core 0.2.0

package/dist/index.js

@@ -0,0 +1,822 @@
+import { n as isRetryable, r as isSDKError, t as SDKError } from "./errors-DJ6U6cHY.js";
+import { a as ReadTokenPayloadSchema, c as CallbackAuth, d as RefreshableTokenAuth, f as StaticTokenAuth, i as ProjectScopedTokenPayloadSchema, l as NoAuth, n as CreateSessionRequestSchema, o as SendMessageRequestSchema, r as ProductSchema, s as SessionScopedTokenPayloadSchema, t as BatchScopedTokenPayloadSchema, u as ReadTokenAuth } from "./types-DC6OJ1um.js";
+import { EnvTokenAuth, ProductAuth, ProductTokenIssuer, SidecarAuth, canBatchTokenAccessChannel, canProjectTokenAccessChannel, canSessionTokenAccessChannel, canTokenAccessChannel, decodeToken, extractProjectFromChannel, extractSessionFromChannel, generateApiKey, generateSecureToken, generateSigningSecret, getAllowedChannelPatterns, getTokenScope, getTokenTTL, hashApiKey, isBatchScopedToken, isProjectScopedToken, isSessionScopedToken, isTokenExpiringSoon, issueBatchScopedToken, issueProjectScopedToken, issueReadToken, issueSessionScopedToken, validateChannelSubscription, validateTokenScope, verifyApiKey, verifyReadToken } from "./auth/index.js";
+import { n as EventChannel, r as EventBuffer, t as EventDeduplicator } from "./events-CUWh9qrv.js";
+import { a as sleep, c as CircuitOpenError, i as createTimeoutController, n as withProtection, o as withTimeout, r as TimeoutError, s as CircuitBreaker, t as createProtectedFn } from "./resilience-BQzDfw_C.js";
+import { SSEChunkParser, StreamUsageExtractor, consumeSSEStream, createStreamUsageExtractor, createUsageCallback, parseSSEData, parseSSEStream } from "./sse/index.js";
+import { i as DEFAULT_RECONNECTION_CONFIG, n as BaseTransportAdapter, r as ConnectionManager, t as MockTransportAdapter } from "./transport-mKLoQep5.js";
+import { a as isTextPart, i as isSubtaskPart, n as isFilePart, o as isToolPart, r as isReasoningPart, t as AgentEventTypeSchema } from "./types-D5VLaol0.js";
+//#region src/cache/index.ts
+/** In-memory LRU cache */
+var MemoryCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxEntries;
+	constructor(maxEntries = 1e3) {
+		this.maxEntries = maxEntries;
+	}
+	get(key) {
+		const entry = this.cache.get(key);
+		if (!entry) return void 0;
+		if (Date.now() > entry.expiresAt) {
+			this.cache.delete(key);
+			return;
+		}
+		this.cache.delete(key);
+		this.cache.set(key, entry);
+		return entry;
+	}
+	set(key, value) {
+		if (this.cache.size >= this.maxEntries) {
+			const oldest = this.cache.keys().next().value;
+			if (oldest) this.cache.delete(oldest);
+		}
+		this.cache.set(key, value);
+	}
+	delete(key) {
+		this.cache.delete(key);
+	}
+	clear() {
+		this.cache.clear();
+	}
+	/** Get cache stats */
+	stats() {
+		return {
+			size: this.cache.size,
+			maxEntries: this.maxEntries
+		};
+	}
+};
+/** Response cache manager */
+var ResponseCache = class {
+	storage;
+	defaultTtlMs;
+	keyGenerator;
+	constructor(config = {}) {
+		this.storage = new MemoryCache(config.maxEntries);
+		this.defaultTtlMs = config.defaultTtlMs ?? 6e4;
+		this.keyGenerator = config.keyGenerator ?? this.defaultKeyGenerator;
+	}
+	defaultKeyGenerator(path, params) {
+		if (!params || Object.keys(params).length === 0) return path;
+		return `${path}?${Object.keys(params).sort().map((k) => `${k}=${JSON.stringify(params[k])}`).join("&")}`;
+	}
+	/** Get cached response */
+	async get(path, params) {
+		const key = this.keyGenerator(path, params);
+		return (await this.storage.get(key))?.data;
+	}
+	/** Get with stale-while-revalidate support */
+	async getWithMeta(path, params) {
+		const key = this.keyGenerator(path, params);
+		const entry = await this.storage.get(key);
+		if (!entry) return void 0;
+		const stale = Date.now() > entry.expiresAt;
+		return {
+			data: entry.data,
+			stale,
+			etag: entry.etag
+		};
+	}
+	/** Cache response */
+	async set(path, data, options) {
+		const key = this.keyGenerator(path, options?.params);
+		const now = Date.now();
+		const ttl = options?.ttlMs ?? this.defaultTtlMs;
+		await this.storage.set(key, {
+			data,
+			cachedAt: now,
+			expiresAt: now + ttl,
+			etag: options?.etag
+		});
+	}
+	/** Invalidate cache entry */
+	async invalidate(path, params) {
+		const key = this.keyGenerator(path, params);
+		await this.storage.delete(key);
+	}
+	/** Invalidate all entries matching prefix */
+	async invalidatePrefix(_prefix) {
+		if (this.storage instanceof MemoryCache) this.storage.clear();
+	}
+	/** Clear entire cache */
+	async clear() {
+		await this.storage.clear();
+	}
+	/** Parse Cache-Control header */
+	static parseCacheControl(header) {
+		const result = {};
+		const parts = header.split(",").map((p) => p.trim().toLowerCase());
+		for (const part of parts) {
+			if (part === "no-cache") result.noCache = true;
+			if (part === "no-store") result.noStore = true;
+			if (part.startsWith("max-age=")) {
+				const age = Number.parseInt(part.slice(8), 10);
+				if (!Number.isNaN(age)) result.maxAge = age * 1e3;
+			}
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/middleware/index.ts
+/** Interceptor chain executor */
+var InterceptorChain = class {
+	interceptors = [];
+	/** Add interceptor to chain */
+	use(interceptor) {
+		this.interceptors.push(interceptor);
+		return this;
+	}
+	/** Remove interceptor */
+	remove(interceptor) {
+		const idx = this.interceptors.indexOf(interceptor);
+		if (idx >= 0) this.interceptors.splice(idx, 1);
+		return this;
+	}
+	/** Run request through interceptors */
+	async executeRequest(ctx) {
+		let current = ctx;
+		for (const interceptor of this.interceptors) if (interceptor.onRequest) current = await interceptor.onRequest(current);
+		return current;
+	}
+	/** Run response through interceptors (reverse order) */
+	async executeResponse(ctx) {
+		let data = ctx.data;
+		for (let i = this.interceptors.length - 1; i >= 0; i--) {
+			const interceptor = this.interceptors[i];
+			if (interceptor.onResponse) data = await interceptor.onResponse({
+				...ctx,
+				data
+			});
+		}
+		return data;
+	}
+	/** Notify interceptors of error */
+	async executeError(ctx) {
+		for (const interceptor of this.interceptors) if (interceptor.onError) await interceptor.onError(ctx);
+	}
+};
+/** Generate unique request ID */
+function generateRequestId() {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/** Logging interceptor */
+function createLoggingInterceptor(logger = console) {
+	return {
+		onRequest(ctx) {
+			logger.debug?.(`[${ctx.requestId}] ${ctx.request.method ?? "GET"} ${ctx.request.path}`, { attempt: ctx.attempt });
+			return ctx;
+		},
+		onResponse(ctx) {
+			logger.info?.(`[${ctx.request.requestId}] ${ctx.request.request.method ?? "GET"} ${ctx.request.request.path} ${ctx.status ?? 200} (${ctx.durationMs}ms)`);
+			return ctx.data;
+		},
+		onError(ctx) {
+			logger.error?.(`[${ctx.request.requestId}] ${ctx.request.request.method ?? "GET"} ${ctx.request.request.path} ${ctx.error.code} (${ctx.durationMs}ms)`, { error: ctx.error.message });
+		}
+	};
+}
+/** Metrics interceptor */
+function createMetricsInterceptor(onMetric) {
+	return {
+		onResponse(ctx) {
+			onMetric({
+				path: ctx.request.request.path,
+				method: ctx.request.request.method ?? "GET",
+				status: "success",
+				durationMs: ctx.durationMs
+			});
+			return ctx.data;
+		},
+		onError(ctx) {
+			onMetric({
+				path: ctx.request.request.path,
+				method: ctx.request.request.method ?? "GET",
+				status: "error",
+				durationMs: ctx.durationMs,
+				errorCode: ctx.error.code
+			});
+		}
+	};
+}
+/** Header injection interceptor */
+function createHeaderInterceptor(headers) {
+	return { async onRequest(ctx) {
+		const h = typeof headers === "function" ? await headers() : headers;
+		return {
+			...ctx,
+			request: {
+				...ctx.request,
+				headers: {
+					...ctx.request.headers,
+					...h
+				}
+			}
+		};
+	} };
+}
+//#endregion
+//#region src/storage/index.ts
+/** In-memory storage (default fallback) */
+var MemoryStorage = class {
+	data = /* @__PURE__ */ new Map();
+	async get(key) {
+		const value = this.data.get(key);
+		if (!value) return null;
+		try {
+			return JSON.parse(value);
+		} catch {
+			return null;
+		}
+	}
+	async set(key, value) {
+		this.data.set(key, JSON.stringify(value));
+	}
+	async delete(key) {
+		this.data.delete(key);
+	}
+	async clear() {
+		this.data.clear();
+	}
+	async keys() {
+		return Array.from(this.data.keys());
+	}
+};
+/** Browser localStorage wrapper */
+var LocalStorage = class {
+	constructor(prefix = "sdk_") {
+		this.prefix = prefix;
+	}
+	key(k) {
+		return `${this.prefix}${k}`;
+	}
+	async get(key) {
+		if (typeof localStorage === "undefined") return null;
+		const value = localStorage.getItem(this.key(key));
+		if (!value) return null;
+		try {
+			return JSON.parse(value);
+		} catch {
+			return null;
+		}
+	}
+	async set(key, value) {
+		if (typeof localStorage === "undefined") return;
+		localStorage.setItem(this.key(key), JSON.stringify(value));
+	}
+	async delete(key) {
+		if (typeof localStorage === "undefined") return;
+		localStorage.removeItem(this.key(key));
+	}
+	async clear() {
+		if (typeof localStorage === "undefined") return;
+		const keys = await this.keys();
+		for (const key of keys) localStorage.removeItem(this.key(key));
+	}
+	async keys() {
+		if (typeof localStorage === "undefined") return [];
+		const result = [];
+		for (let i = 0; i < localStorage.length; i++) {
+			const key = localStorage.key(i);
+			if (key?.startsWith(this.prefix)) result.push(key.slice(this.prefix.length));
+		}
+		return result;
+	}
+};
+/** Offline queue manager */
+var OfflineQueue = class {
+	storageKey = "offline_queue";
+	constructor(storage) {
+		this.storage = storage;
+	}
+	/** Add request to queue */
+	async enqueue(request) {
+		const queue = await this.getQueue();
+		const id = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+		queue.push({
+			...request,
+			id,
+			createdAt: Date.now(),
+			attempts: 0
+		});
+		await this.storage.set(this.storageKey, queue);
+		return id;
+	}
+	/** Get all queued requests */
+	async getQueue() {
+		return await this.storage.get(this.storageKey) ?? [];
+	}
+	/** Get next request to process */
+	async peek() {
+		return (await this.getQueue())[0] ?? null;
+	}
+	/** Remove request from queue */
+	async dequeue(id) {
+		const filtered = (await this.getQueue()).filter((r) => r.id !== id);
+		await this.storage.set(this.storageKey, filtered);
+	}
+	/** Increment attempt count */
+	async incrementAttempts(id) {
+		const queue = await this.getQueue();
+		const request = queue.find((r) => r.id === id);
+		if (request) {
+			request.attempts++;
+			await this.storage.set(this.storageKey, queue);
+		}
+	}
+	/** Get queue size */
+	async size() {
+		return (await this.getQueue()).length;
+	}
+	/** Clear queue */
+	async clear() {
+		await this.storage.delete(this.storageKey);
+	}
+	/** Process queue with handler */
+	async process(handler, options) {
+		const maxAttempts = options?.maxAttempts ?? 3;
+		const batchSize = options?.batchSize ?? 10;
+		const queue = await this.getQueue();
+		let processed = 0;
+		let failed = 0;
+		for (let i = 0; i < Math.min(queue.length, batchSize); i++) {
+			const request = queue[i];
+			if (request.attempts >= maxAttempts) {
+				await this.dequeue(request.id);
+				failed++;
+				continue;
+			}
+			try {
+				if (await handler(request)) {
+					await this.dequeue(request.id);
+					processed++;
+				} else await this.incrementAttempts(request.id);
+			} catch {
+				await this.incrementAttempts(request.id);
+			}
+		}
+		return {
+			processed,
+			failed
+		};
+	}
+};
+/** Detect available storage */
+function detectStorage() {
+	if (typeof localStorage !== "undefined") return new LocalStorage();
+	return new MemoryStorage();
+}
+//#endregion
+//#region src/platform/index.ts
+/**
+* Platform Abstraction Layer
+*
+* Interfaces and adapters that enable the SDK to run across
+* mobile, desktop, TUI, and web without vendor lock-in.
+*
+* Each platform provides its own implementations:
+* - Web: localStorage, navigator.onLine, fetch
+* - React Native: AsyncStorage, NetInfo, fetch polyfill
+* - Electron: electron-store, net module, node-fetch
+* - Tauri: tauri-plugin-store, tauri events, fetch
+* - Node/TUI: fs-based, always online, node-fetch
+*/
+/**
+* In-memory secure storage fallback.
+* NOT SECURE - use only for development/testing.
+*/
+var MemorySecureStorage = class {
+	credentials = /* @__PURE__ */ new Map();
+	async setCredential(key, value) {
+		this.credentials.set(key, value);
+	}
+	async getCredential(key) {
+		return this.credentials.get(key) ?? null;
+	}
+	async deleteCredential(key) {
+		this.credentials.delete(key);
+	}
+	async isAvailable() {
+		return true;
+	}
+};
+/**
+* Browser-based network info using navigator.onLine.
+*/
+var BrowserNetworkInfo = class {
+	isOnline() {
+		return typeof navigator !== "undefined" ? navigator.onLine : true;
+	}
+	onConnectivityChange(callback) {
+		if (typeof window === "undefined") return () => {};
+		const onOnline = () => callback(true);
+		const onOffline = () => callback(false);
+		window.addEventListener("online", onOnline);
+		window.addEventListener("offline", onOffline);
+		return () => {
+			window.removeEventListener("online", onOnline);
+			window.removeEventListener("offline", onOffline);
+		};
+	}
+	getConnectionType() {
+		const nav = navigator;
+		if (nav.connection?.type) {
+			const type = nav.connection.type;
+			if (type === "wifi") return "wifi";
+			if (type === "cellular") return "cellular";
+			if (type === "ethernet") return "ethernet";
+		}
+		return "unknown";
+	}
+};
+/**
+* Node.js network info (assumes always online).
+*/
+var NodeNetworkInfo = class {
+	isOnline() {
+		return true;
+	}
+	onConnectivityChange(_callback) {
+		return () => {};
+	}
+};
+/**
+* Storage-based persistence adapter.
+* Uses provided Storage implementation for state persistence.
+*/
+var StoragePersistence = class {
+	constructor(storage) {
+		this.storage = storage;
+	}
+	async saveState(namespace, state) {
+		await this.storage.set(`state:${namespace}`, state);
+	}
+	async loadState(namespace) {
+		return this.storage.get(`state:${namespace}`);
+	}
+	async clearState(namespace) {
+		await this.storage.delete(`state:${namespace}`);
+	}
+};
+/**
+* Browser persistence with localStorage and storage events for tab sync.
+*/
+var BrowserPersistence = class {
+	prefix;
+	constructor(prefix = "sdk_state:") {
+		this.prefix = prefix;
+	}
+	async saveState(namespace, state) {
+		if (typeof localStorage === "undefined") return;
+		localStorage.setItem(`${this.prefix}${namespace}`, JSON.stringify(state));
+	}
+	async loadState(namespace) {
+		if (typeof localStorage === "undefined") return null;
+		const value = localStorage.getItem(`${this.prefix}${namespace}`);
+		if (!value) return null;
+		try {
+			return JSON.parse(value);
+		} catch {
+			return null;
+		}
+	}
+	async clearState(namespace) {
+		if (typeof localStorage === "undefined") return;
+		localStorage.removeItem(`${this.prefix}${namespace}`);
+	}
+	onExternalChange(namespace, callback) {
+		if (typeof window === "undefined") return () => {};
+		const key = `${this.prefix}${namespace}`;
+		const handler = (event) => {
+			if (event.key === key && event.newValue) try {
+				callback(JSON.parse(event.newValue));
+			} catch {}
+		};
+		window.addEventListener("storage", handler);
+		return () => window.removeEventListener("storage", handler);
+	}
+};
+/**
+* Detect current platform.
+*/
+function detectPlatform() {
+	if (typeof window !== "undefined" && "__TAURI__" in window) return "tauri";
+	if (typeof process !== "undefined" && process.versions && "electron" in process.versions) return "electron";
+	if (typeof navigator !== "undefined" && navigator.product === "ReactNative") return "react-native";
+	if (typeof window !== "undefined" && typeof document !== "undefined") return "web";
+	return "node";
+}
+/**
+* Create default platform adapter for current environment.
+* Override with platform-specific implementations for better integration.
+*/
+function createDefaultPlatformAdapter() {
+	const platform = detectPlatform();
+	const isBrowser = platform === "web" || platform === "tauri";
+	const storage = detectStorage();
+	return {
+		capabilities: {
+			platform,
+			supportsBackground: platform === "node" || platform === "electron",
+			supportsSecureStorage: false,
+			supportsWebSocket: true,
+			supportsSSE: true,
+			maxConnections: isBrowser ? 6 : void 0
+		},
+		storage,
+		secureStorage: new MemorySecureStorage(),
+		network: isBrowser ? new BrowserNetworkInfo() : new NodeNetworkInfo(),
+		persistence: isBrowser ? new BrowserPersistence() : new StoragePersistence(storage),
+		fetch: globalThis.fetch.bind(globalThis)
+	};
+}
+/**
+* Type-safe platform adapter factory.
+* Use this to create platform adapters with proper typing.
+*/
+function createPlatformAdapter(config) {
+	return {
+		...createDefaultPlatformAdapter(),
+		...config
+	};
+}
+//#endregion
+//#region src/retry/index.ts
+/**
+* Request Retry Logic
+*
+* Per-request retry with exponential backoff and idempotency.
+*/
+const DEFAULT_RETRY_CONFIG = {
+	maxAttempts: 3,
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4,
+	multiplier: 2,
+	jitter: .2
+};
+/** Calculate delay for attempt with jitter */
+function calculateDelay(attempt, config) {
+	const { initialDelayMs, maxDelayMs, multiplier, jitter } = {
+		...DEFAULT_RETRY_CONFIG,
+		...config
+	};
+	const baseDelay = Math.min(initialDelayMs * multiplier ** attempt, maxDelayMs);
+	const jitterRange = baseDelay * jitter;
+	const jitterValue = Math.random() * jitterRange * 2 - jitterRange;
+	return Math.max(0, Math.floor(baseDelay + jitterValue));
+}
+/** Execute function with retry */
+async function withRetry(fn, config = {}) {
+	const maxAttempts = config.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts;
+	let lastError = null;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) try {
+		return await fn(attempt);
+	} catch (error) {
+		lastError = SDKError.fromError(error);
+		if (!(config.shouldRetry ? config.shouldRetry(lastError, attempt) : isRetryable(lastError)) || attempt >= maxAttempts - 1) throw lastError;
+		const delay = lastError.retryAfterMs ?? calculateDelay(attempt, config);
+		config.onRetry?.(lastError, attempt + 1, delay);
+		await sleep$1(delay);
+	}
+	throw lastError ?? new SDKError("Max retries exceeded", { code: "UNKNOWN" });
+}
+/** Sleep utility */
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Idempotency key generator */
+function generateIdempotencyKey() {
+	return `idem_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Retry decorator for class methods */
+function Retryable(config = {}) {
+	return (_target, _propertyKey, descriptor) => {
+		const original = descriptor.value;
+		if (!original) return descriptor;
+		descriptor.value = async function(...args) {
+			return withRetry((_attempt) => {
+				return original.apply(this, args);
+			}, config);
+		};
+		return descriptor;
+	};
+}
+//#endregion
+//#region src/telemetry/genai-attributes.ts
+/**
+* OpenTelemetry GenAI semantic-convention span attributes — the single
+* vocabulary every trace producer in the stack emits and the intelligence
+* ingest reads, so model / token / cost attribution is identical regardless of
+* which producer lowered the span (workflow emitter, SDK trace sink, …).
+*
+* Writers emit the PRIMARY keys (`GEN_AI_*`). The ingest reader accepts the
+* wider candidate lists (`GEN_AI_*_KEYS`) because foreign SDKs spell the same
+* field differently (Langfuse, raw OTLP GenAI, our own legacy `model`).
+* Co-locating writer keys and reader candidates here is the drift guard: a
+* writer's key and the reader's first candidate can never silently disagree.
+*
+* Spec: OpenTelemetry GenAI semantic conventions (`gen_ai.*`).
+*/
+/** Model that served a request — the primary key writers emit. */
+const GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+/** Model named on a response — a reader fallback; writers prefer request.model. */
+const GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+/** Prompt / input token count. */
+const GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+/** Completion / output token count. */
+const GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+/** Operation name (e.g. `"invoke_agent"`). */
+const GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+/** Conversation / session id grouping a multi-turn agent run. */
+const GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
+/**
+* Reader candidate keys for the model, highest priority first. The first entry
+* is the writers' primary key; the rest accept foreign-SDK spellings.
+*/
+const GEN_AI_MODEL_KEYS = Object.freeze([
+	GEN_AI_REQUEST_MODEL,
+	GEN_AI_RESPONSE_MODEL,
+	"llm.model_name",
+	"model"
+]);
+/** Reader candidate keys for input tokens, highest priority first. These name
+*  SPAN ATTRIBUTES on a lowered span — for the raw producer `tokenUsage` OBJECT
+*  field names (a distinct layer) see `TOKEN_USAGE_INPUT_KEYS` in
+*  `token-usage.ts`; a new producer shape may need an entry in both. */
+const GEN_AI_INPUT_TOKEN_KEYS = Object.freeze([
+	GEN_AI_USAGE_INPUT_TOKENS,
+	"gen_ai.usage.prompt_tokens",
+	"llm.token_count.prompt"
+]);
+/** Reader candidate keys for output tokens, highest priority first. */
+const GEN_AI_OUTPUT_TOKEN_KEYS = Object.freeze([
+	GEN_AI_USAGE_OUTPUT_TOKENS,
+	"gen_ai.usage.completion_tokens",
+	"llm.token_count.completion"
+]);
+function isNonNegativeFinite(n) {
+	return typeof n === "number" && Number.isFinite(n) && n >= 0;
+}
+/**
+* Lower a usage record to the GenAI semantic-convention attribute bag, OMITTING
+* any unknown field. A synthesized zero token count or empty model would
+* corrupt every downstream token/cost aggregate, so absent stays absent — the
+* ingest then reads "cost not computed", never "free". This is the writer-side
+* mirror of {@link GEN_AI_MODEL_KEYS} / the `*_TOKEN_KEYS` reader candidates.
+*/
+function genAiUsageAttributes(usage) {
+	const attrs = {};
+	if (typeof usage.model === "string" && usage.model.length > 0) attrs[GEN_AI_REQUEST_MODEL] = usage.model;
+	if (isNonNegativeFinite(usage.inputTokens)) attrs[GEN_AI_USAGE_INPUT_TOKENS] = usage.inputTokens;
+	if (isNonNegativeFinite(usage.outputTokens)) attrs[GEN_AI_USAGE_OUTPUT_TOKENS] = usage.outputTokens;
+	return attrs;
+}
+//#endregion
+//#region src/telemetry/token-usage.ts
+/**
+* Candidate field names for a producer-supplied `tokenUsage` bag on a
+* `message.updated` trace event. Agents and SDK layers disagree on the
+* spelling: `StreamTokenUsage` emits `inputTokens`/`outputTokens`, the eval and
+* workflow agent.run paths emit `input`/`output`, and persisted / foreign
+* shapes use snake_case or prompt/completion naming. A reader that wants the
+* token counts must try all of them, highest-priority first, or it silently
+* drops usage for the producers it does not name.
+*
+* Shared so every `tokenUsage` reader (the trace sink's root-span aggregation,
+* the signal extractor) keys off the identical set and cannot drift.
+*
+* Distinct layer from `genai-attributes.ts`: those keys (`GEN_AI_*_TOKEN_KEYS`)
+* name OTel SPAN ATTRIBUTES on an already-lowered span; these name the fields of
+* the raw producer `tokenUsage` OBJECT before lowering. A new producer that
+* spells token usage differently may need an entry in BOTH places.
+*/
+const TOKEN_USAGE_INPUT_KEYS = Object.freeze([
+	"inputTokens",
+	"input",
+	"input_tokens",
+	"promptTokens",
+	"prompt_tokens"
+]);
+const TOKEN_USAGE_OUTPUT_KEYS = Object.freeze([
+	"outputTokens",
+	"output",
+	"output_tokens",
+	"completionTokens",
+	"completion_tokens"
+]);
+//#endregion
+//#region src/utils/channel-matching.ts
+/**
+* Channel Pattern Matching
+*
+* Generic utility for matching channel patterns with wildcard support.
+* Used for channel subscriptions and event filtering.
+*
+* Pattern syntax:
+* - "*" matches all channels
+* - "foo.*" matches "foo.bar", "foo.baz", etc. (dot-separated)
+* - "foo:*" matches "foo:bar", "foo:baz", etc. (colon-separated)
+* - "foo.bar" matches exactly "foo.bar"
+* - "session:abc" matches exactly "session:abc"
+*/
+/**
+* Check if a pattern matches a channel name.
+*
+* @param pattern - The pattern to match against (supports wildcards)
+* @param channel - The channel name to check
+* @returns true if the pattern matches the channel
+*/
+function matchesChannel(pattern, channel) {
+	if (pattern === "*") return true;
+	if (pattern.endsWith(".*")) {
+		const prefix = pattern.slice(0, -2);
+		return channel.startsWith(`${prefix}.`);
+	}
+	if (pattern.endsWith(":*")) {
+		const prefix = pattern.slice(0, -2);
+		return channel.startsWith(`${prefix}:`) && channel.length > prefix.length + 1;
+	}
+	return pattern === channel;
+}
+/**
+* Check if any subscribed channel pattern matches the given channel.
+*
+* @param subscribedChannels - Set or array of channel patterns
+* @param channel - The channel to check
+* @returns true if any pattern matches the channel
+*/
+function matchesAnyChannel(subscribedChannels, channel) {
+	return (Array.isArray(subscribedChannels) ? subscribedChannels : Array.from(subscribedChannels)).some((pattern) => matchesChannel(pattern, channel));
+}
+//#endregion
+//#region src/utils/session-translator.ts
+/**
+* Escape special regex characters in a string.
+*/
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Translate session IDs in an event object.
+* Performs a deep string replacement via JSON serialization.
+*
+* @param event - The event object to translate
+* @param translation - The session ID mapping
+* @returns A new event object with translated session IDs
+*/
+function translateSessionId(event, translation) {
+	if (!event || typeof event !== "object") return event;
+	if (translation.from === translation.to) return event;
+	if (!translation.from) return event;
+	try {
+		const json = JSON.stringify(event);
+		const pattern = new RegExp(escapeRegex(translation.from), "g");
+		const translated = json.replace(pattern, translation.to);
+		if (translated !== json) return JSON.parse(translated);
+		return event;
+	} catch {
+		return event;
+	}
+}
+/**
+* Create a reusable translator function for a specific session mapping.
+* Pre-compiles the regex pattern for better performance when translating
+* many events with the same mapping.
+*/
+function createSessionTranslator(translation) {
+	const pattern = new RegExp(escapeRegex(translation.from), "g");
+	return (event) => {
+		if (!event || typeof event !== "object") return event;
+		if (translation.from === translation.to || !translation.from) return event;
+		try {
+			const json = JSON.stringify(event);
+			const translated = json.replace(pattern, translation.to);
+			if (translated !== json) return JSON.parse(translated);
+			return event;
+		} catch {
+			return event;
+		}
+	};
+}
+/**
+* Extract session ID from various event structures.
+* Handles different event formats that may contain session information.
+*/
+function extractSessionId(event) {
+	if (!event || typeof event !== "object") return null;
+	const obj = event;
+	if (typeof obj.sessionId === "string") return obj.sessionId;
+	if (obj.properties && typeof obj.properties === "object") {
+		const props = obj.properties;
+		if (typeof props.sessionId === "string") return props.sessionId;
+	}
+	if (obj.data && typeof obj.data === "object") {
+		const data = obj.data;
+		if (typeof data.sessionId === "string") return data.sessionId;
+	}
+	return null;
+}
+//#endregion
+export { AgentEventTypeSchema, BaseTransportAdapter, BatchScopedTokenPayloadSchema, BrowserNetworkInfo, BrowserPersistence, CallbackAuth, CircuitBreaker, CircuitOpenError, ConnectionManager, CreateSessionRequestSchema, DEFAULT_RECONNECTION_CONFIG, EnvTokenAuth, EventBuffer, EventChannel, EventDeduplicator, 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, InterceptorChain, LocalStorage, MemoryCache, MemorySecureStorage, MemoryStorage, MockTransportAdapter, NoAuth, NodeNetworkInfo, OfflineQueue, ProductAuth, ProductSchema, ProductTokenIssuer, ProjectScopedTokenPayloadSchema, ReadTokenAuth, ReadTokenPayloadSchema, RefreshableTokenAuth, ResponseCache, Retryable, SDKError, SSEChunkParser, SendMessageRequestSchema, SessionScopedTokenPayloadSchema, SidecarAuth, StaticTokenAuth, StoragePersistence, StreamUsageExtractor, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, TimeoutError, calculateDelay, canBatchTokenAccessChannel, canProjectTokenAccessChannel, canSessionTokenAccessChannel, canTokenAccessChannel, consumeSSEStream, createDefaultPlatformAdapter, createHeaderInterceptor, createLoggingInterceptor, createMetricsInterceptor, createPlatformAdapter, createProtectedFn, createSessionTranslator, createStreamUsageExtractor, createTimeoutController, createUsageCallback, decodeToken, detectPlatform, detectStorage, extractProjectFromChannel, extractSessionFromChannel, extractSessionId, genAiUsageAttributes, generateApiKey, generateIdempotencyKey, generateRequestId, generateSecureToken, generateSigningSecret, getAllowedChannelPatterns, getTokenScope, getTokenTTL, hashApiKey, isBatchScopedToken, isFilePart, isProjectScopedToken, isReasoningPart, isRetryable, isSDKError, isSessionScopedToken, isSubtaskPart, isTextPart, isTokenExpiringSoon, isToolPart, issueBatchScopedToken, issueProjectScopedToken, issueReadToken, issueSessionScopedToken, matchesAnyChannel, matchesChannel, parseSSEData, parseSSEStream, sleep, translateSessionId, validateChannelSubscription, validateTokenScope, verifyApiKey, verifyReadToken, withProtection, withRetry, withTimeout };
+
+//# sourceMappingURL=index.js.map