@posthog/mcp 0.0.0

package/dist/index.mjs

@@ -0,0 +1,2692 @@
+import { createRequire } from "node:module";
+import { PostHog } from "posthog-node";
+import { createHash, randomUUID } from "node:crypto";
+import { CallToolRequestSchema, InitializeRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/modules/logging.ts
+let fsModule$1 = null;
+let logFilePath = null;
+let initAttempted = false;
+let useConsoleFallback = false;
+/**
+* Attempts to initialize Node.js file logging.
+* Falls back to console.log in edge environments where fs/os modules are unavailable.
+*/
+function tryInitSync() {
+	if (initAttempted) return;
+	initAttempted = true;
+	try {
+		const require = createRequire(import.meta.url);
+		const fs = require("node:fs");
+		const os = require("node:os");
+		const path = require("node:path");
+		const home = os.homedir?.();
+		if (home) {
+			fsModule$1 = fs;
+			logFilePath = path.join(home, "posthog-mcp-analytics.log");
+		} else useConsoleFallback = true;
+	} catch {
+		useConsoleFallback = true;
+		fsModule$1 = null;
+		logFilePath = null;
+	}
+}
+function writeToLog(message) {
+	tryInitSync();
+	const logEntry = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}`;
+	if (useConsoleFallback) return;
+	if (!(logFilePath && fsModule$1)) return;
+	try {
+		if (fsModule$1.existsSync(logFilePath)) fsModule$1.appendFileSync(logFilePath, `${logEntry}\n`);
+		else fsModule$1.writeFileSync(logFilePath, `${logEntry}\n`);
+	} catch {}
+}
+//#endregion
+//#region src/modules/compatibility.ts
+/**
+* PostHog MCP analytics Compatibility Module
+*
+* This module ensures compatibility with Model Context Protocol TypeScript SDK.
+* PostHog MCP analytics only supports MCP SDK version 1.11 and above.
+*
+* Version 1.11+ is required because it introduced stable APIs for:
+* - Tool registration and handling
+* - Request handler access patterns
+* - Client version detection
+* - Server info structure
+*/
+function logCompatibilityWarning() {
+	writeToLog("PostHog MCP analytics SDK Compatibility: This version only supports Model Context Protocol TypeScript SDK v1.11 and above. Please upgrade if using an older version.");
+}
+function isHighLevelServer(server) {
+	return !!server && typeof server === "object" && "server" in server && !!server.server && typeof server.server === "object";
+}
+function isCompatibleServerType(server) {
+	if (!server || typeof server !== "object") {
+		logCompatibilityWarning();
+		throw new Error("PostHog MCP analytics SDK compatibility error: Server must be an object. Ensure you're using MCP SDK v1.11 or higher.");
+	}
+	if (isHighLevelServer(server)) {
+		if (!server._registeredTools || typeof server._registeredTools !== "object") {
+			logCompatibilityWarning();
+			throw new Error("PostHog MCP analytics SDK compatibility error: High-level server must have _registeredTools object. This requires MCP SDK v1.11 or higher.");
+		}
+		if (typeof server.tool !== "function") {
+			logCompatibilityWarning();
+			throw new Error("PostHog MCP analytics SDK compatibility error: High-level server must have tool() method. This requires MCP SDK v1.11 or higher.");
+		}
+		const targetServer = server.server;
+		validateLowLevelServer(targetServer);
+		return server;
+	}
+	validateLowLevelServer(server);
+	return server;
+}
+function validateLowLevelServer(server) {
+	if (!server || typeof server !== "object") {
+		logCompatibilityWarning();
+		throw new Error("PostHog MCP analytics SDK compatibility error: Server must be an object. Ensure you're using MCP SDK v1.11 or higher.");
+	}
+	const serverRecord = server;
+	if (typeof serverRecord.setRequestHandler !== "function") {
+		logCompatibilityWarning();
+		throw new Error("PostHog MCP analytics SDK compatibility error: Server must have a setRequestHandler method. This requires MCP SDK v1.11 or higher.");
+	}
+	if (!(serverRecord._requestHandlers && serverRecord._requestHandlers instanceof Map)) {
+		logCompatibilityWarning();
+		throw new Error("PostHog MCP analytics SDK compatibility error: Server._requestHandlers is not accessible. This requires MCP SDK v1.11 or higher.");
+	}
+	if (typeof serverRecord._requestHandlers.get !== "function") {
+		logCompatibilityWarning();
+		throw new Error("PostHog MCP analytics SDK compatibility error: Server._requestHandlers must be a Map with a get method. This requires MCP SDK v1.11 or higher.");
+	}
+	if (typeof serverRecord.getClientVersion !== "function") {
+		logCompatibilityWarning();
+		throw new Error("PostHog MCP analytics SDK compatibility error: Server.getClientVersion must be a function. This requires MCP SDK v1.11 or higher.");
+	}
+	if (!serverRecord._serverInfo || typeof serverRecord._serverInfo !== "object" || !("name" in serverRecord._serverInfo)) {
+		logCompatibilityWarning();
+		throw new Error("PostHog MCP analytics SDK compatibility error: Server._serverInfo is not accessible or missing name. This requires MCP SDK v1.11 or higher.");
+	}
+}
+function getMCPCompatibleErrorMessage(error) {
+	if (error instanceof Error) try {
+		return JSON.stringify(error, Object.getOwnPropertyNames(error));
+	} catch {
+		return "Unknown error";
+	}
+	else if (typeof error === "string") return error;
+	else if (typeof error === "object" && error !== null) return JSON.stringify(error);
+	return "Unknown error";
+}
+//#endregion
+//#region src/modules/ids.ts
+function newPrefixedId(prefix) {
+	return `${prefix}_${randomUUID()}`;
+}
+function deterministicPrefixedId(prefix, input) {
+	return `${prefix}_${createHash("sha256").update(input).digest("hex").slice(0, 32)}`;
+}
+//#endregion
+//#region src/modules/event-types.ts
+const MCPAnalyticsEventType = {
+	identify: "posthog:identify",
+	custom: "posthog:custom",
+	mcpInitialize: "mcp:initialize",
+	mcpPromptsGet: "mcp:prompts/get",
+	mcpPromptsList: "mcp:prompts/list",
+	mcpResourcesList: "mcp:resources/list",
+	mcpResourcesRead: "mcp:resources/read",
+	mcpToolsCall: "mcp:tools/call",
+	mcpToolsList: "mcp:tools/list"
+};
+//#endregion
+//#region src/modules/validation.ts
+const TAG_KEY_REGEX = /^[a-zA-Z0-9$_.:\- ]+$/;
+const MAX_TAG_KEY_LENGTH = 32;
+const MAX_TAG_VALUE_LENGTH = 200;
+const MAX_TAG_ENTRIES = 50;
+/**
+* Validates and filters a tags object against PostHog MCP analytics tag constraints.
+* Invalid entries are logged as warnings and dropped.
+* Returns null if no valid entries remain.
+*/
+function validateTags(tags) {
+	const entries = Object.entries(tags);
+	if (entries.length === 0) return null;
+	const valid = [];
+	for (const [key, value] of entries) {
+		if (typeof key !== "string" || !TAG_KEY_REGEX.test(key)) {
+			writeToLog(`Dropping invalid tag: "${String(key)}" — key contains invalid characters or is empty`);
+			continue;
+		}
+		if (key.length > MAX_TAG_KEY_LENGTH) {
+			writeToLog(`Dropping invalid tag: "${key}" — key exceeds max length of ${MAX_TAG_KEY_LENGTH}`);
+			continue;
+		}
+		if (typeof value !== "string") {
+			writeToLog(`Dropping invalid tag: "${key}" — non-string value (got ${typeof value})`);
+			continue;
+		}
+		if (value.length > MAX_TAG_VALUE_LENGTH) {
+			writeToLog(`Dropping invalid tag: "${key}" — value exceeds max length of ${MAX_TAG_VALUE_LENGTH}`);
+			continue;
+		}
+		if (value.includes("\n")) {
+			writeToLog(`Dropping invalid tag: "${key}" — value contains newline character`);
+			continue;
+		}
+		valid.push([key, value]);
+	}
+	if (valid.length === 0) return null;
+	if (valid.length > MAX_TAG_ENTRIES) {
+		writeToLog(`Dropping ${valid.length - MAX_TAG_ENTRIES} tag(s) — exceeds maximum of ${MAX_TAG_ENTRIES} entries per event`);
+		valid.length = MAX_TAG_ENTRIES;
+	}
+	return Object.fromEntries(valid);
+}
+//#endregion
+//#region src/modules/internal.ts
+/**
+* Simple LRU cache for session identities.
+* Prevents memory leaks by capping at maxSize entries.
+* This cache persists across server instance restarts.
+*/
+var IdentityCache = class {
+	constructor(maxSize = 1e3) {
+		this.cache = /* @__PURE__ */ new Map();
+		this.maxSize = maxSize;
+	}
+	get(sessionId) {
+		const entry = this.cache.get(sessionId);
+		if (entry) {
+			entry.timestamp = Date.now();
+			this.cache.delete(sessionId);
+			this.cache.set(sessionId, entry);
+			return entry.identity;
+		}
+	}
+	set(sessionId, identity) {
+		this.cache.delete(sessionId);
+		if (this.cache.size >= this.maxSize) {
+			const oldestKey = this.cache.keys().next().value;
+			if (oldestKey !== void 0) this.cache.delete(oldestKey);
+		}
+		this.cache.set(sessionId, {
+			identity,
+			timestamp: Date.now()
+		});
+	}
+	has(sessionId) {
+		return this.cache.has(sessionId);
+	}
+	size() {
+		return this.cache.size;
+	}
+};
+const _globalIdentityCache = new IdentityCache(1e3);
+const _serverTracking = /* @__PURE__ */ new WeakMap();
+function getServerTrackingData(server) {
+	return _serverTracking.get(server);
+}
+function setServerTrackingData(server, data) {
+	_serverTracking.set(server, data);
+}
+/**
+* Deep comparison of two UserIdentity objects
+*/
+function areIdentitiesEqual(a, b) {
+	if (a.userId !== b.userId) return false;
+	if (a.userName !== b.userName) return false;
+	const aData = a.userData || {};
+	const bData = b.userData || {};
+	const aKeys = Object.keys(aData);
+	const bKeys = Object.keys(bData);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) {
+		if (!(key in bData)) return false;
+		if (JSON.stringify(aData[key]) !== JSON.stringify(bData[key])) return false;
+	}
+	return true;
+}
+/**
+* Merges two UserIdentity objects, overwriting userId and userName,
+* but merging userData fields
+*/
+function mergeIdentities(previous, next) {
+	if (!previous) return next;
+	return {
+		userId: next.userId,
+		userName: next.userName,
+		userData: {
+			...previous.userData || {},
+			...next.userData || {}
+		}
+	};
+}
+/**
+* Handles user identification for a request.
+* Calls the identify function if configured, compares with previous identity,
+* and publishes an identify event only if the identity has changed.
+*
+* @param server - The MCP server instance
+* @param data - The server tracking data
+* @param request - The request object to pass to identify function
+* @param extra - Optional extra parameters containing headers, sessionId, etc.
+*/
+async function handleIdentify(server, data, request, extra) {
+	if (!data.options.identify) return;
+	const sessionId = data.sessionId;
+	const identifyEvent = {
+		sessionId,
+		resourceName: getRequestResourceName(request),
+		eventType: MCPAnalyticsEventType.identify,
+		parameters: {
+			request,
+			extra
+		},
+		timestamp: /* @__PURE__ */ new Date(),
+		redactionFn: data.options.redactSensitiveInformation
+	};
+	try {
+		const identityResult = await data.options.identify(request, extra);
+		if (identityResult) {
+			const currentSessionId = data.sessionId;
+			const previousIdentity = _globalIdentityCache.get(currentSessionId);
+			const mergedIdentity = mergeIdentities(previousIdentity, identityResult);
+			const hasChanged = !(previousIdentity && areIdentitiesEqual(previousIdentity, mergedIdentity));
+			_globalIdentityCache.set(currentSessionId, mergedIdentity);
+			data.identifiedSessions.set(data.sessionId, mergedIdentity);
+			if (hasChanged) {
+				writeToLog(`Identified session ${currentSessionId} with identity: ${JSON.stringify(mergedIdentity)}`);
+				publishEvent(server, identifyEvent);
+			}
+		} else writeToLog(`Warning: Supplied identify function returned null for session ${sessionId}`);
+	} catch (error) {
+		writeToLog(`Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`);
+	}
+}
+/**
+* Resolves the eventTags callback, validates the result, and returns validated tags.
+* Returns null if no callback configured, callback returns nullish, or callback throws.
+*/
+async function resolveEventTags(data, request, extra) {
+	if (!data.options.eventTags) return null;
+	try {
+		const raw = await data.options.eventTags(request, extra) ?? null;
+		if (!raw) return null;
+		return validateTags(raw);
+	} catch (e) {
+		writeToLog(`eventTags callback error: ${e}`);
+		return null;
+	}
+}
+/**
+* Resolves the eventProperties callback and returns the result.
+* Returns null if no callback configured, callback returns nullish, or callback throws.
+*/
+async function resolveEventProperties(data, request, extra) {
+	if (!data.options.eventProperties) return null;
+	try {
+		return await data.options.eventProperties(request, extra) ?? null;
+	} catch (e) {
+		writeToLog(`eventProperties callback error: ${e}`);
+		return null;
+	}
+}
+function getRequestResourceName(request) {
+	if (!request || typeof request !== "object" || !("params" in request)) return "Unknown";
+	const params = request.params;
+	if (!params || typeof params !== "object" || !("name" in params)) return "Unknown";
+	return typeof params.name === "string" ? params.name : "Unknown";
+}
+//#endregion
+//#region src/modules/constants.ts
+const DEFAULT_CONTEXT_PARAMETER_DESCRIPTION = `Explain why you are calling this tool and how it fits into the user's overall goal. This parameter is used for analytics and user intent tracking. YOU MUST provide 15-25 words (count carefully). NEVER use first person ('I', 'we', 'you') - maintain third-person perspective. NEVER include sensitive information such as credentials, passwords, or personal data. Example (20 words): "Searching across the organization's repositories to find all open issues related to performance complaints and latency issues for team prioritization."`;
+const POSTHOG_MCP_ANALYTICS_SOURCE = "posthog_mcp_analytics";
+const PostHogMCPAnalyticsProperty = {
+	AiInputState: "$ai_input_state",
+	AiIsError: "$ai_is_error",
+	AiLatency: "$ai_latency",
+	AiOutputState: "$ai_output_state",
+	AiProduct: "$ai_product",
+	AiSessionId: "$ai_session_id",
+	AiSpanId: "$ai_span_id",
+	AiSpanName: "$ai_span_name",
+	AiTraceId: "$ai_trace_id",
+	ClientName: "$mcp_client_name",
+	ClientVersion: "$mcp_client_version",
+	DurationMs: "$mcp_duration_ms",
+	IsError: "$mcp_is_error",
+	Intent: "$mcp_intent",
+	Parameters: "$mcp_parameters",
+	ResourceName: "$mcp_resource_name",
+	Response: "$mcp_response",
+	ServerName: "$mcp_server_name",
+	ServerVersion: "$mcp_server_version",
+	SessionId: "$session_id",
+	Source: "$mcp_source",
+	ToolName: "$mcp_tool_name"
+};
+//#endregion
+//#region src/modules/posthog-events.ts
+const MCP_EVENT_PREFIX_REGEX = /^mcp:/;
+const SLASH_REGEX = /\//g;
+function getDistinctId(event) {
+	return event.identifyActorGivenId || event.sessionId || "anonymous";
+}
+function getTimestamp(event) {
+	return event.timestamp ? event.timestamp.toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+}
+function buildPostHogCaptureEvents(event, options = {}) {
+	const batch = [buildCaptureEvent(event, options)];
+	if (event.isError && event.error) batch.push(buildExceptionEvent(event));
+	if (shouldBuildAISpan(event, options)) batch.push(buildAISpanEvent(event));
+	return batch;
+}
+function buildCaptureEvent(event, options) {
+	const distinctId = getDistinctId(event);
+	const eventName = mapEventType(event.eventType);
+	const timestamp = getTimestamp(event);
+	const properties = {
+		[PostHogMCPAnalyticsProperty.SessionId]: event.sessionId,
+		[PostHogMCPAnalyticsProperty.Source]: POSTHOG_MCP_ANALYTICS_SOURCE
+	};
+	addCommonEventProperties(event, properties);
+	addTraceReferenceProperties(event, properties, options);
+	addCustomEventProperties(event, properties);
+	return {
+		event: eventName,
+		distinct_id: distinctId,
+		properties,
+		timestamp,
+		type: "capture"
+	};
+}
+function shouldBuildAISpan(event, options) {
+	return options.enableAITracing === true && event.eventType === MCPAnalyticsEventType.mcpToolsCall;
+}
+function getAITraceId(event) {
+	return event.sessionId;
+}
+function getAISpanId(event) {
+	return event.id;
+}
+function addTraceReferenceProperties(event, properties, options) {
+	if (!shouldBuildAISpan(event, options)) return;
+	properties[PostHogMCPAnalyticsProperty.AiTraceId] = getAITraceId(event);
+	properties[PostHogMCPAnalyticsProperty.AiSpanId] = getAISpanId(event);
+}
+function addCommonEventProperties(event, properties) {
+	if (event.resourceName) {
+		properties[PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName;
+		if (event.eventType === MCPAnalyticsEventType.mcpToolsCall) properties[PostHogMCPAnalyticsProperty.ToolName] = event.resourceName;
+	}
+	if (event.duration !== void 0) properties[PostHogMCPAnalyticsProperty.DurationMs] = event.duration;
+	if (event.serverName) properties[PostHogMCPAnalyticsProperty.ServerName] = event.serverName;
+	if (event.serverVersion) properties[PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion;
+	if (event.clientName) properties[PostHogMCPAnalyticsProperty.ClientName] = event.clientName;
+	if (event.clientVersion) properties[PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion;
+	if (event.userIntent) properties[PostHogMCPAnalyticsProperty.Intent] = event.userIntent;
+	if (event.isError !== void 0) properties[PostHogMCPAnalyticsProperty.IsError] = event.isError;
+	if (event.parameters !== void 0) properties[PostHogMCPAnalyticsProperty.Parameters] = event.parameters;
+	if (event.response !== void 0) properties[PostHogMCPAnalyticsProperty.Response] = event.response;
+	const $set = {};
+	if (event.identifyActorName) $set.name = event.identifyActorName;
+	if (event.identifyActorData) Object.assign($set, event.identifyActorData);
+	if (Object.keys($set).length > 0) properties.$set = $set;
+}
+function addCustomEventProperties(event, properties) {
+	if (event.tags) for (const [key, value] of Object.entries(event.tags)) properties[key] = value;
+	if (event.properties) for (const [key, value] of Object.entries(event.properties)) properties[key] = value;
+}
+function buildExceptionEvent(event) {
+	const distinctId = getDistinctId(event);
+	const timestamp = getTimestamp(event);
+	const properties = {
+		$exception_source: "backend",
+		[PostHogMCPAnalyticsProperty.SessionId]: event.sessionId
+	};
+	if (event.error) {
+		if (event.error.message) properties.$exception_message = event.error.message;
+		if (event.error.type) properties.$exception_type = event.error.type;
+		if (event.error.stack) properties.$exception_stacktrace = event.error.stack;
+	}
+	if (event.resourceName) {
+		properties[PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName;
+		if (event.eventType === MCPAnalyticsEventType.mcpToolsCall) properties[PostHogMCPAnalyticsProperty.ToolName] = event.resourceName;
+	}
+	if (event.serverName) properties[PostHogMCPAnalyticsProperty.ServerName] = event.serverName;
+	if (event.serverVersion) properties[PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion;
+	if (event.clientName) properties[PostHogMCPAnalyticsProperty.ClientName] = event.clientName;
+	if (event.clientVersion) properties[PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion;
+	return {
+		event: "$exception",
+		distinct_id: distinctId,
+		properties,
+		timestamp,
+		type: "capture"
+	};
+}
+function buildAISpanEvent(event) {
+	const distinctId = getDistinctId(event);
+	const timestamp = getTimestamp(event);
+	const properties = {
+		[PostHogMCPAnalyticsProperty.AiSessionId]: `posthog_mcp_analytics_${event.sessionId}`,
+		[PostHogMCPAnalyticsProperty.AiTraceId]: getAITraceId(event),
+		[PostHogMCPAnalyticsProperty.AiSpanId]: getAISpanId(event),
+		[PostHogMCPAnalyticsProperty.AiSpanName]: event.resourceName || "unknown_tool",
+		[PostHogMCPAnalyticsProperty.AiIsError]: event.isError,
+		[PostHogMCPAnalyticsProperty.SessionId]: event.sessionId,
+		[PostHogMCPAnalyticsProperty.Source]: POSTHOG_MCP_ANALYTICS_SOURCE
+	};
+	if (event.duration !== void 0) properties[PostHogMCPAnalyticsProperty.AiLatency] = event.duration / 1e3;
+	if (event.isError && event.error) properties.$ai_error = event.error;
+	if (event.parameters !== void 0) properties[PostHogMCPAnalyticsProperty.AiInputState] = event.parameters;
+	if (event.response !== void 0) properties[PostHogMCPAnalyticsProperty.AiOutputState] = event.response;
+	if (event.serverName) properties[PostHogMCPAnalyticsProperty.ServerName] = event.serverName;
+	if (event.clientName) properties[PostHogMCPAnalyticsProperty.ClientName] = event.clientName;
+	if (event.userIntent) properties[PostHogMCPAnalyticsProperty.Intent] = event.userIntent;
+	if (event.tags) for (const [key, value] of Object.entries(event.tags)) properties[key] = value;
+	if (event.properties) for (const [key, value] of Object.entries(event.properties)) properties[key] = value;
+	return {
+		event: "$ai_span",
+		distinct_id: distinctId,
+		properties,
+		timestamp,
+		type: "capture"
+	};
+}
+function mapEventType(eventType) {
+	return {
+		[MCPAnalyticsEventType.mcpToolsCall]: "mcp_tool_call",
+		[MCPAnalyticsEventType.mcpToolsList]: "mcp_tools_list",
+		[MCPAnalyticsEventType.mcpInitialize]: "mcp_initialize",
+		[MCPAnalyticsEventType.mcpResourcesRead]: "mcp_resource_read",
+		[MCPAnalyticsEventType.mcpResourcesList]: "mcp_resources_list",
+		[MCPAnalyticsEventType.mcpPromptsGet]: "mcp_prompt_get",
+		[MCPAnalyticsEventType.mcpPromptsList]: "mcp_prompts_list"
+	}[eventType] || `mcp_${eventType.replace(MCP_EVENT_PREFIX_REGEX, "").replace(SLASH_REGEX, "_")}`;
+}
+//#endregion
+//#region src/modules/redaction.ts
+/**
+* Set of field names that should be protected from redaction.
+* These fields contain system-level identifiers and metadata that
+* need to be preserved for analytics tracking.
+*/
+const PROTECTED_FIELDS = new Set([
+	"sessionId",
+	"id",
+	"apiKey",
+	"server",
+	"identifyActorGivenId",
+	"identifyActorName",
+	"identifyData",
+	"resourceName",
+	"eventType",
+	"actorId",
+	"tags",
+	"properties"
+]);
+/**
+* Recursively applies a redaction function to all string values in an object.
+* This ensures that sensitive information is removed from all string fields
+* before events are sent to the analytics service.
+*
+* @param obj - The object to redact strings from
+* @param redactFn - The redaction function to apply to each string
+* @param path - The current path in the object tree (used to check protected fields)
+* @param isProtected - Whether the current object/value is within a protected field
+* @returns A new object with all strings redacted
+*/
+async function redactStringsInObject(obj, redactFn, path = "", isProtected = false) {
+	if (obj === null || obj === void 0) return obj;
+	if (typeof obj === "string") {
+		if (isProtected) return obj;
+		return await redactFn(obj);
+	}
+	if (Array.isArray(obj)) return Promise.all(obj.map((item, index) => redactStringsInObject(item, redactFn, `${path}[${index}]`, isProtected)));
+	if (obj instanceof Date) return obj;
+	if (typeof obj === "object") {
+		const redactedObj = {};
+		for (const [key, value] of Object.entries(obj)) {
+			if (typeof value === "function" || value === void 0) continue;
+			redactedObj[key] = await redactStringsInObject(value, redactFn, path ? `${path}.${key}` : key, isProtected || path === "" && PROTECTED_FIELDS.has(key));
+		}
+		return redactedObj;
+	}
+	return obj;
+}
+/**
+* Applies the customer's redaction function to all string fields in an Event object.
+* This is the main entry point for redacting sensitive information from events
+* before they are sent to the analytics service.
+*
+* @param event - The event to redact
+* @param redactFn - The customer's redaction function
+* @returns A new event object with all strings redacted
+*/
+function redactEvent(event, redactFn) {
+	return redactStringsInObject(event, redactFn, "", false);
+}
+//#endregion
+//#region src/modules/mcp-payloads.ts
+const CONTEXT_ARGUMENT_NAME = "context";
+const REDACTED_VALUE = "[redacted]";
+const BASE64_PATTERN = /^[A-Za-z0-9+/\n\r]+=*$/;
+const SIZE_GATE = 10240;
+const POSTHOG_TOKEN_PATTERN = /\bph[a-z]_[A-Za-z0-9_-]{20,}\b/g;
+const SENSITIVE_KEY_PATTERN = /^(authorization|cookie|set-cookie|x-api-key|api[-_]?key|api[-_]?token|access[-_]?token|refresh[-_]?token|token|password|secret|client[-_]?secret|private[-_]?key)$/i;
+function isRecord$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function shouldRedactKey(key) {
+	return SENSITIVE_KEY_PATTERN.test(key);
+}
+function sanitizeString(value) {
+	if (value.length >= SIZE_GATE && BASE64_PATTERN.test(value)) return "[binary data redacted - not supported by PostHog MCP analytics]";
+	return value.replace(POSTHOG_TOKEN_PATTERN, REDACTED_VALUE);
+}
+function sanitizeCapturedValue(value) {
+	if (value == null) return value;
+	if (typeof value === "string") return sanitizeString(value);
+	if (Array.isArray(value)) return value.map(sanitizeCapturedValue);
+	if (value instanceof Date) return value;
+	if (typeof value !== "object") return value;
+	const result = {};
+	for (const [key, nestedValue] of Object.entries(value)) result[key] = shouldRedactKey(key) ? REDACTED_VALUE : sanitizeCapturedValue(nestedValue);
+	return result;
+}
+function buildCapturedMcpArguments(argumentsValue) {
+	if (!isRecord$1(argumentsValue)) return sanitizeCapturedValue(argumentsValue);
+	const capturedArguments = {};
+	for (const [key, value] of Object.entries(argumentsValue)) {
+		if (key === CONTEXT_ARGUMENT_NAME) continue;
+		capturedArguments[key] = sanitizeCapturedValue(value);
+	}
+	return capturedArguments;
+}
+function buildCapturedMcpParams(params) {
+	if (!isRecord$1(params)) return sanitizeCapturedValue(params);
+	const capturedParams = {};
+	for (const [key, value] of Object.entries(params)) capturedParams[key] = key === "arguments" ? buildCapturedMcpArguments(value) : sanitizeCapturedValue(value);
+	return capturedParams;
+}
+function buildCapturedMcpParameters(request) {
+	if (!isRecord$1(request)) return { request: sanitizeCapturedValue(request) };
+	const capturedRequest = {};
+	for (const key of [
+		"id",
+		"jsonrpc",
+		"method"
+	]) if (key in request) capturedRequest[key] = sanitizeCapturedValue(request[key]);
+	if ("params" in request) capturedRequest.params = buildCapturedMcpParams(request.params);
+	return { request: capturedRequest };
+}
+//#endregion
+//#region src/modules/sanitization.ts
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Sanitizes an event by redacting non-text content blocks from responses
+* and large base64-encoded strings from parameters.
+*
+* This is a synchronous operation that returns a new object without mutating the original.
+* It should run after customer redaction in the event pipeline.
+*/
+function sanitizeEvent(event) {
+	const result = { ...event };
+	if (result.response != null) result.response = sanitizeResponse(result.response);
+	if (result.parameters != null) result.parameters = sanitizeParameters(result.parameters);
+	return result;
+}
+/**
+* Sanitizes response content blocks by replacing non-text content types
+* with informative redaction messages.
+*/
+function sanitizeResponse(response) {
+	if (response == null || typeof response !== "object") return sanitizeCapturedValue(response);
+	const sanitized = sanitizeCapturedValue(response);
+	if (!isRecord(sanitized)) return sanitized;
+	const result = { ...sanitized };
+	const content = result.content;
+	if (Array.isArray(content)) result.content = content.map(sanitizeContentBlock);
+	if (result.structuredContent != null && typeof result.structuredContent === "object") result.structuredContent = sanitizeCapturedValue(result.structuredContent);
+	return result;
+}
+/**
+* Sanitizes a single content block based on its type discriminator.
+*/
+function sanitizeContentBlock(block) {
+	if (block == null || typeof block !== "object") return block;
+	if (!isRecord(block)) return block;
+	switch (block.type) {
+		case "text": return sanitizeCapturedValue(block);
+		case "image": return {
+			type: "text",
+			text: "[image content redacted - not supported by PostHog MCP analytics]"
+		};
+		case "audio": return {
+			type: "text",
+			text: "[audio content redacted - not supported by PostHog MCP analytics]"
+		};
+		case "resource": return sanitizeResourceBlock(block);
+		case "resource_link": return sanitizeCapturedValue(block);
+		default: return {
+			type: "text",
+			text: `[unsupported content type "${block.type}" redacted - not supported by PostHog MCP analytics]`
+		};
+	}
+}
+/**
+* Sanitizes an embedded resource content block.
+* BlobResourceContents (has `blob` field) are redacted.
+* TextResourceContents (has `text` field) pass through.
+*/
+function sanitizeResourceBlock(block) {
+	if (isRecord(block.resource) && "blob" in block.resource) return {
+		type: "text",
+		text: "[binary resource content redacted - not supported by PostHog MCP analytics]"
+	};
+	return sanitizeCapturedValue(block);
+}
+/**
+* Recursively scans parameters for large base64-encoded strings and replaces them.
+* Uses a size gate (10KB) to avoid regex testing on small strings.
+*/
+function sanitizeParameters(obj) {
+	return sanitizeCapturedValue(obj);
+}
+//#endregion
+//#region package.json
+var version = "0.0.0";
+//#endregion
+//#region src/modules/session.ts
+function newSessionId() {
+	return newPrefixedId("ses");
+}
+/**
+* Creates a deterministic SDK session ID from an MCP sessionId.
+* The same inputs will always produce the same session ID, enabling correlation across server restarts.
+*
+* @param mcpSessionId - The session ID from the MCP protocol
+* @returns An SDK session ID with "ses" prefix derived deterministically from the inputs
+*/
+function deriveSessionIdFromMCPSession(mcpSessionId) {
+	return deterministicPrefixedId("ses", mcpSessionId);
+}
+/**
+* Gets or generates a session ID for the server.
+* Prioritizes MCP protocol sessionId over PostHog MCP analytics-generated sessionId.
+*
+* @param server - The MCP server instance
+* @param extra - Optional extra data containing MCP sessionId
+* @returns The session ID to use for events
+*/
+function getServerSessionId(server, extra) {
+	const data = getServerTrackingData(server);
+	if (!data) throw new Error("Server tracking data not found");
+	const mcpSessionId = extra?.sessionId;
+	if (mcpSessionId) {
+		data.sessionId = deriveSessionIdFromMCPSession(mcpSessionId);
+		data.lastMcpSessionId = mcpSessionId;
+		data.sessionSource = "mcp";
+		setServerTrackingData(server, data);
+		setLastActivity(server);
+		return data.sessionId;
+	}
+	if (data.sessionSource === "mcp" && data.lastMcpSessionId) {
+		setLastActivity(server);
+		return data.sessionId;
+	}
+	if (Date.now() - data.lastActivity.getTime() > 1800 * 1e3) {
+		data.sessionId = newSessionId();
+		data.sessionSource = "generated";
+		setServerTrackingData(server, data);
+	}
+	setLastActivity(server);
+	return data.sessionId;
+}
+function setLastActivity(server) {
+	const data = getServerTrackingData(server);
+	if (!data) throw new Error("Server tracking data not found");
+	data.lastActivity = /* @__PURE__ */ new Date();
+	setServerTrackingData(server, data);
+}
+function getSessionInfo(server, data) {
+	let clientInfo = {
+		name: void 0,
+		version: void 0
+	};
+	if (!data?.sessionInfo.clientName) clientInfo = server.getClientVersion();
+	const actorInfo = data?.identifiedSessions.get(data.sessionId);
+	const sessionInfo = {
+		ipAddress: void 0,
+		sdkLanguage: "TypeScript",
+		sdkVersion: version,
+		serverName: server._serverInfo?.name,
+		serverVersion: server._serverInfo?.version,
+		clientName: clientInfo?.name,
+		clientVersion: clientInfo?.version,
+		identifyActorGivenId: actorInfo?.userId,
+		identifyActorName: actorInfo?.userName,
+		identifyActorData: actorInfo?.userData || {}
+	};
+	if (!data) return sessionInfo;
+	data.sessionInfo = sessionInfo;
+	setServerTrackingData(server, data);
+	return data.sessionInfo;
+}
+const MAX_STRING_LENGTH = 32768;
+const MAX_EVENT_BYTES = 102400;
+const MAX_USER_INTENT_LENGTH = 2048;
+const MAX_ERROR_MESSAGE_LENGTH = 2048;
+const MAX_RESOURCE_NAME_LENGTH = 256;
+const MAX_METADATA_LENGTH = 256;
+const MAX_STACK_FRAMES$1 = 50;
+const MAX_CONTENT_TEXT_LENGTH = 32768;
+const TRUNCATION_SUFFIX = "...";
+/**
+* Recursively normalizes a value, handling:
+* - String truncation (> MAX_STRING_LENGTH)
+* - Non-serializable values (functions, symbols, undefined, BigInt, NaN, Infinity)
+* - Date objects -> ISO string
+* - Circular reference detection
+* - Depth limiting
+* - Breadth limiting
+*/
+function normalize(input, depth = 10, maxBreadth = 100, maxStringLength = MAX_STRING_LENGTH) {
+	return visit(input, depth, maxBreadth, maxStringLength, /* @__PURE__ */ new WeakSet());
+}
+function visit(value, remainingDepth, maxBreadth, maxStringLength, memo) {
+	if (value === null) return null;
+	if (value === void 0) return "[undefined]";
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (Number.isNaN(value)) return "[NaN]";
+		if (!Number.isFinite(value)) return value > 0 ? "[Infinity]" : "[-Infinity]";
+		return value;
+	}
+	if (typeof value === "bigint") return `[BigInt: ${value}]`;
+	if (typeof value === "string") {
+		if (value.length > maxStringLength) return value.slice(0, maxStringLength) + TRUNCATION_SUFFIX;
+		return value;
+	}
+	if (typeof value === "symbol") {
+		const desc = value.description;
+		return desc ? `[Symbol(${desc})]` : "[Symbol()]";
+	}
+	if (typeof value === "function") return `[Function: ${value.name || "<anonymous>"}]`;
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? "[Invalid Date]" : value.toISOString();
+	if (typeof value === "object") {
+		if (memo.has(value)) return "[Circular ~]";
+		if (remainingDepth <= 0) return Array.isArray(value) ? "[Array]" : "[Object]";
+		memo.add(value);
+		let result;
+		if (Array.isArray(value)) result = visitArray(value, remainingDepth - 1, maxBreadth, maxStringLength, memo);
+		else result = visitObject(value, remainingDepth - 1, maxBreadth, maxStringLength, memo);
+		memo.delete(value);
+		return result;
+	}
+	return String(value);
+}
+function visitArray(arr, remainingDepth, maxBreadth, maxStringLength, memo) {
+	const result = [];
+	for (let i = 0; i < arr.length; i++) {
+		if (i >= maxBreadth) {
+			result.push("[MaxProperties ~]");
+			break;
+		}
+		result.push(visit(arr[i], remainingDepth, maxBreadth, maxStringLength, memo));
+	}
+	return result;
+}
+function visitObject(obj, remainingDepth, maxBreadth, maxStringLength, memo) {
+	const result = {};
+	const keys = Object.keys(obj);
+	let count = 0;
+	for (const key of keys) {
+		if (count >= maxBreadth) {
+			result["..."] = "[MaxProperties ~]";
+			break;
+		}
+		if (obj[key] === void 0) continue;
+		result[key] = visit(obj[key], remainingDepth, maxBreadth, maxStringLength, memo);
+		count++;
+	}
+	return result;
+}
+function truncateString(str, maxLength) {
+	if (str == null) return str;
+	if (str.length <= maxLength) return str;
+	return str.slice(0, maxLength) + TRUNCATION_SUFFIX;
+}
+function truncateStackFrames(frames) {
+	if (!frames || frames.length <= MAX_STACK_FRAMES$1) return frames;
+	const half = Math.floor(MAX_STACK_FRAMES$1 / 2);
+	return [...frames.slice(0, half), ...frames.slice(-half)];
+}
+function truncateResponseContent(response) {
+	if (response == null || typeof response !== "object") return response;
+	const result = { ...response };
+	if (Array.isArray(result.content)) result.content = result.content.map((block) => {
+		if (block != null && typeof block === "object" && "type" in block && "text" in block && block?.type === "text" && typeof block.text === "string" && block.text.length > MAX_CONTENT_TEXT_LENGTH) return {
+			...block,
+			text: block.text.slice(0, MAX_CONTENT_TEXT_LENGTH) + TRUNCATION_SUFFIX
+		};
+		return block;
+	});
+	return result;
+}
+/**
+* Calculates the UTF-8 byte size of a JSON-serialized value.
+*/
+const textEncoder = new TextEncoder();
+function jsonByteSize(value) {
+	return textEncoder.encode(JSON.stringify(value)).length;
+}
+/**
+* Finds and truncates the largest string values in an object to fit within a byte budget.
+* Last-resort mechanism when depth reduction alone isn't enough.
+* Iterates until the result fits or no further reduction is possible.
+*/
+function truncateLargestFields(obj, maxBytes) {
+	const result = structuredClone(obj);
+	for (let attempt = 0; attempt < 10; attempt++) {
+		const currentSize = jsonByteSize(result);
+		if (currentSize <= maxBytes) return result;
+		const excess = currentSize - maxBytes;
+		const stringPaths = [];
+		collectStringPaths(result, [], stringPaths);
+		stringPaths.sort((a, b) => b.length - a.length);
+		if (stringPaths.length === 0) break;
+		let remaining = excess + 200;
+		let truncated = false;
+		for (const { path, length } of stringPaths) {
+			if (remaining <= 0) break;
+			const reduction = Math.min(remaining, Math.floor(length * .5));
+			if (reduction < 10) continue;
+			const newLength = length - reduction;
+			const currentValue = getNestedValue(result, path);
+			if (typeof currentValue !== "string") continue;
+			setNestedValue(result, path, currentValue.slice(0, newLength) + TRUNCATION_SUFFIX);
+			remaining -= reduction;
+			truncated = true;
+		}
+		if (!truncated) break;
+	}
+	return result;
+}
+function collectStringPaths(obj, currentPath, results) {
+	if (typeof obj === "string" && obj.length > 100) {
+		results.push({
+			path: [...currentPath],
+			length: obj.length
+		});
+		return;
+	}
+	if (Array.isArray(obj)) {
+		for (const [i, item] of obj.entries()) collectStringPaths(item, [...currentPath, String(i)], results);
+		return;
+	}
+	if (obj != null && typeof obj === "object") for (const [key, value] of Object.entries(obj)) collectStringPaths(value, [...currentPath, key], results);
+}
+function getNestedValue(obj, path) {
+	let current = obj;
+	for (const key of path) {
+		if (current == null || typeof current !== "object") return;
+		current = current[key];
+	}
+	return current;
+}
+function setNestedValue(obj, path, value) {
+	let current = obj;
+	for (let i = 0; i < path.length - 1; i++) {
+		if (current == null || typeof current !== "object") return;
+		current = current[path[i]];
+	}
+	const finalKey = path.at(-1);
+	if (finalKey !== void 0 && current != null && typeof current === "object") current[finalKey] = value;
+}
+/**
+* Ensures an event fits within MAX_EVENT_BYTES by progressively reducing
+* normalization depth, then truncating largest string fields as a last resort.
+*/
+function truncateToSize(event) {
+	if (jsonByteSize(event) <= 102400) return event;
+	for (let depth = 9; depth >= 1; depth--) {
+		const reduced = { ...event };
+		if (reduced.parameters != null) reduced.parameters = normalize(reduced.parameters, depth);
+		if (reduced.response != null) reduced.response = normalize(reduced.response, depth);
+		if (reduced.identifyActorData != null) reduced.identifyActorData = normalize(reduced.identifyActorData, depth);
+		if (reduced.error != null) reduced.error = normalize(reduced.error, depth);
+		if (jsonByteSize(reduced) <= 102400) return reduced;
+	}
+	const minimal = { ...event };
+	if (minimal.parameters != null) minimal.parameters = normalize(minimal.parameters, 1);
+	if (minimal.response != null) minimal.response = normalize(minimal.response, 1);
+	if (minimal.identifyActorData != null) minimal.identifyActorData = normalize(minimal.identifyActorData, 1);
+	if (minimal.error != null) minimal.error = normalize(minimal.error, 1);
+	return truncateLargestFields(minimal, MAX_EVENT_BYTES);
+}
+/**
+* Applies layered truncation to an event:
+* 1. Field-level string limits (userIntent, resourceName, metadata fields, error.message)
+* 2. Error frame limiting (first 25 + last 25 if > 50)
+* 3. Response content text limits (32KB per text block)
+* 4. Recursive normalization on user-controlled fields
+* 5. Size-targeted truncation (progressive depth reduction + last-resort string truncation)
+*/
+function truncateEvent(event) {
+	const result = { ...event };
+	result.userIntent = truncateString(result.userIntent, MAX_USER_INTENT_LENGTH);
+	result.resourceName = truncateString(result.resourceName, MAX_RESOURCE_NAME_LENGTH);
+	result.serverName = truncateString(result.serverName, MAX_METADATA_LENGTH);
+	result.serverVersion = truncateString(result.serverVersion, MAX_METADATA_LENGTH);
+	result.clientName = truncateString(result.clientName, MAX_METADATA_LENGTH);
+	result.clientVersion = truncateString(result.clientVersion, MAX_METADATA_LENGTH);
+	if (result.error != null && typeof result.error === "object") {
+		const error = { ...result.error };
+		error.message = truncateString(error.message, MAX_ERROR_MESSAGE_LENGTH);
+		if (error.frames !== void 0) error.frames = truncateStackFrames(error.frames);
+		result.error = error;
+	}
+	result.response = truncateResponseContent(result.response);
+	if (result.parameters != null) result.parameters = normalize(result.parameters);
+	if (result.response != null) result.response = normalize(result.response);
+	if (result.identifyActorData != null) result.identifyActorData = normalize(result.identifyActorData);
+	if (result.error != null) result.error = normalize(result.error);
+	return truncateToSize(result);
+}
+//#endregion
+//#region src/modules/event-queue.ts
+var EventQueue = class {
+	constructor() {
+		this.queue = [];
+		this.processing = false;
+		this.maxQueueSize = 1e4;
+		this.concurrency = 5;
+		this.activeRequests = 0;
+		this.host = "https://us.i.posthog.com";
+		this.posthogOptions = {};
+		this.posthogClients = /* @__PURE__ */ new Map();
+	}
+	configure(host) {
+		this.host = host;
+		this.posthogClients.clear();
+	}
+	configurePostHogOptions(posthogOptions) {
+		this.posthogOptions = {
+			...this.posthogOptions,
+			...posthogOptions
+		};
+		if (posthogOptions.host) this.host = posthogOptions.host;
+		this.posthogClients.clear();
+	}
+	add(event, posthogClient, enableAITracing = false) {
+		if (this.queue.length >= this.maxQueueSize) {
+			writeToLog("Event queue full, dropping oldest event");
+			this.queue.shift();
+		}
+		this.queue.push({
+			enableAITracing,
+			event,
+			posthogClient
+		});
+		this.process();
+	}
+	async process() {
+		if (this.processing) return;
+		this.processing = true;
+		while (this.queue.length > 0 && this.activeRequests < this.concurrency) {
+			const queuedEvent = this.queue.shift();
+			if (!queuedEvent) continue;
+			const { enableAITracing, event, posthogClient } = queuedEvent;
+			if (event.redactionFn) try {
+				const redactedEvent = await redactEvent(event, event.redactionFn);
+				event.redactionFn = void 0;
+				Object.assign(event, redactedEvent);
+			} catch (error) {
+				writeToLog(`Failed to redact event: ${error}`);
+				continue;
+			}
+			try {
+				Object.assign(event, sanitizeEvent(event));
+			} catch (error) {
+				writeToLog(`Failed to sanitize event: ${error}`);
+				continue;
+			}
+			try {
+				Object.assign(event, truncateEvent(event));
+			} catch (error) {
+				writeToLog(`Failed to truncate event: ${error}`);
+				continue;
+			}
+			event.id = event.id || newPrefixedId("evt");
+			this.activeRequests++;
+			try {
+				this.sendEvent(event, posthogClient, enableAITracing);
+			} finally {
+				this.activeRequests--;
+				this.process();
+			}
+		}
+		this.processing = false;
+	}
+	sendEvent(event, posthogClientOverride, enableAITracing = false) {
+		const posthogClient = this.getPostHogClient(event.apiKey, posthogClientOverride);
+		if (posthogClient) try {
+			for (const captureEvent of buildPostHogCaptureEvents(event, { enableAITracing })) posthogClient.capture({
+				distinctId: captureEvent.distinct_id,
+				event: captureEvent.event,
+				properties: captureEvent.properties,
+				timestamp: new Date(captureEvent.timestamp)
+			});
+			writeToLog(`Queued PostHog event ${event.id} | ${event.eventType} | ${event.duration} ms | ${event.identifyActorGivenId || "anonymous"}`);
+			writeToLog(`Event details: ${JSON.stringify(event)}`);
+		} catch (error) {
+			writeToLog(`Failed to queue PostHog event ${event.id}: ${getMCPCompatibleErrorMessage(error)}`);
+			throw error;
+		}
+	}
+	getPostHogClient(apiKey, posthogClient) {
+		if (posthogClient) return posthogClient;
+		if (!apiKey) return;
+		const existingClient = this.posthogClients.get(apiKey);
+		if (existingClient) return existingClient;
+		const client = new PostHog(apiKey, {
+			...this.posthogOptions,
+			host: this.host
+		});
+		this.posthogClients.set(apiKey, client);
+		return client;
+	}
+	delay(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	getStats() {
+		return {
+			queueLength: this.queue.length,
+			activeRequests: this.activeRequests,
+			isProcessing: this.processing
+		};
+	}
+	async destroy() {
+		this.add = () => {
+			writeToLog("Queue is shutting down, event dropped");
+		};
+		const timeout = 5e3;
+		const start = Date.now();
+		while ((this.queue.length > 0 || this.activeRequests > 0) && Date.now() - start < timeout) await this.delay(100);
+		if (this.queue.length > 0) writeToLog(`Shutting down with ${this.queue.length} events still in queue`);
+		const shutdowns = [];
+		for (const client of this.posthogClients.values()) if (client.shutdown) shutdowns.push(client.shutdown(timeout));
+		else if (client.flush) shutdowns.push(client.flush());
+		await Promise.allSettled(shutdowns);
+	}
+};
+const eventQueue = new EventQueue();
+try {
+	if (typeof process !== "undefined" && typeof process.once === "function") {
+		process.once("SIGINT", () => eventQueue.destroy());
+		process.once("SIGTERM", () => eventQueue.destroy());
+		process.once("beforeExit", () => eventQueue.destroy());
+	}
+} catch {}
+function publishEvent(server, eventInput) {
+	const data = getServerTrackingData(server);
+	if (!data) {
+		writeToLog("Warning: Server tracking data not found. Event will not be published.");
+		return;
+	}
+	if (!data.options.enableTracing) return;
+	const sessionInfo = getSessionInfo(server, data);
+	const duration = eventInput.duration || (eventInput.timestamp ? Date.now() - eventInput.timestamp.getTime() : void 0);
+	const fullEvent = {
+		id: eventInput.id || "",
+		sessionId: eventInput.sessionId || data.sessionId,
+		apiKey: data.apiKey,
+		eventType: eventInput.eventType || "",
+		timestamp: eventInput.timestamp || /* @__PURE__ */ new Date(),
+		duration,
+		ipAddress: sessionInfo.ipAddress,
+		sdkLanguage: sessionInfo.sdkLanguage,
+		sdkVersion: sessionInfo.sdkVersion,
+		serverName: sessionInfo.serverName,
+		serverVersion: sessionInfo.serverVersion,
+		clientName: sessionInfo.clientName,
+		clientVersion: sessionInfo.clientVersion,
+		identifyActorGivenId: sessionInfo.identifyActorGivenId,
+		identifyActorName: sessionInfo.identifyActorName,
+		identifyActorData: sessionInfo.identifyActorData,
+		resourceName: eventInput.resourceName,
+		parameters: eventInput.parameters,
+		response: eventInput.response,
+		userIntent: eventInput.userIntent,
+		isError: eventInput.isError,
+		error: eventInput.error,
+		redactionFn: eventInput.redactionFn,
+		tags: eventInput.tags,
+		properties: eventInput.properties
+	};
+	if (data.options.posthogClient) eventQueue.add(fullEvent, data.options.posthogClient, data.options.enableAITracing);
+	else eventQueue.add(fullEvent, void 0, data.options.enableAITracing);
+}
+//#endregion
+//#region src/modules/exceptions.ts
+let fsModule = null;
+let fsInitAttempted = false;
+function getFsSync() {
+	if (!fsInitAttempted) {
+		fsInitAttempted = true;
+		try {
+			fsModule = createRequire(import.meta.url)("node:fs");
+		} catch {
+			fsModule = null;
+		}
+	}
+	return fsModule;
+}
+const MAX_EXCEPTION_CHAIN_DEPTH = 10;
+const MAX_STACK_FRAMES = 50;
+const LOCATION_WITH_LINE_COLUMN_REGEX = /^(.+):(\d+):(\d+)$/;
+const WINDOWS_DRIVE_PREFIX_REGEX = /^[A-Za-z]:/;
+const WINDOWS_ABSOLUTE_PATH_REGEX = /^[A-Za-z]:\\/;
+const WINDOWS_ABSOLUTE_SLASH_PATH_REGEX = /^[A-Za-z]:[/]/;
+const UNIX_USER_HOME_REGEX = /^\/Users\/[^/]+\//;
+const LINUX_USER_HOME_REGEX = /^\/home\/[^/]+\//;
+const WINDOWS_USER_HOME_REGEX = /^[A-Za-z]:[\\/]Users[\\/][^\\/]+[\\/]/;
+const DEPLOYMENT_PREFIX_REGEXES = [
+	/^\/var\/www\/[^/]+\//,
+	/^\/var\/task\//,
+	/^\/usr\/src\/app\//,
+	/^\/app\//,
+	/^\/opt\/[^/]+\//,
+	/^\/srv\/[^/]+\//
+];
+/**
+* Captures detailed exception information including stack traces and cause chains.
+*
+* This function extracts error metadata (type, message, stack trace) and recursively
+* unwraps Error.cause chains. It parses V8 stack traces into structured frames and
+* detects whether each frame is user code (in_app: true) or library code (in_app: false).
+*
+* @param error - The error to capture (can be Error, string, object, or any value)
+* @param contextStack - Optional Error object to use for stack context (for validation errors)
+* @returns ErrorData object with structured error information
+*/
+function captureException(error, contextStack) {
+	if (isCallToolResult(error)) return captureCallToolResultError(error, contextStack);
+	if (!(error instanceof Error)) return {
+		message: stringifyNonError(error),
+		type: void 0,
+		platform: "javascript"
+	};
+	const errorData = {
+		message: error.message || "",
+		type: error.name || error.constructor?.name || void 0,
+		platform: "javascript"
+	};
+	if (error.stack) {
+		errorData.stack = error.stack;
+		errorData.frames = parseV8StackTrace(error.stack);
+	}
+	const chainedErrors = unwrapErrorCauses(error);
+	if (chainedErrors.length > 0) errorData.chained_errors = chainedErrors;
+	return errorData;
+}
+/**
+* Parses V8 stack trace string into structured StackFrame array.
+*
+* V8 stack traces have the format:
+*   Error: message
+*   at functionName (filename:line:col)
+*   at Object.method (filename:line:col)
+*   ...
+*
+* This function handles various V8 format variations including:
+* - Regular functions: "at functionName (file:10:5)"
+* - Anonymous functions: "at file:10:5"
+* - Async functions: "at async functionName (file:10:5)"
+* - Object methods: "at Object.method (file:10:5)"
+* - Native code: "at Array.map (native)"
+*
+* @param stackTrace - Raw V8 stack trace string from Error.stack
+* @returns Array of parsed StackFrame objects (limited to MAX_STACK_FRAMES)
+*/
+function parseV8StackTrace(stackTrace) {
+	const frames = [];
+	const lines = stackTrace.split("\n");
+	for (const line of lines) {
+		if (!line.trim().startsWith("at ")) continue;
+		const frame = parseV8StackFrame(line.trim());
+		if (frame) {
+			addContextToFrame(frame);
+			frames.push(frame);
+		}
+		if (frames.length >= MAX_STACK_FRAMES) break;
+	}
+	return frames;
+}
+/**
+* Adds context_line to a stack frame by reading the source file.
+*
+* This function extracts the line of code where the error occurred by:
+* 1. Reading the source file using abs_path
+* 2. Extracting the line at the specified line number
+* 3. Setting the context_line field on the frame
+*
+* Only extracts context for user code (in_app: true)
+* If the file cannot be read or the line number is invalid, context_line remains undefined.
+*
+* @param frame - The StackFrame to add context to (modified in place)
+* @returns The modified StackFrame
+*/
+function addContextToFrame(frame) {
+	if (!(frame.in_app && frame.abs_path && frame.lineno)) return frame;
+	const fs = getFsSync();
+	if (!fs) return frame;
+	try {
+		const lines = fs.readFileSync(frame.abs_path, "utf8").split("\n");
+		const lineIndex = frame.lineno - 1;
+		if (lineIndex >= 0 && lineIndex < lines.length) frame.context_line = lines[lineIndex];
+	} catch {}
+	return frame;
+}
+/**
+* Parses a location string from a V8 stack frame.
+*
+* Handles different location formats:
+* - "fileName:lineNumber:columnNumber" - normal file location
+* - "eval at functionName (location)" - eval'd code (recursively unwraps)
+* - "native" - V8 internal code
+* - "unknown location" - location unavailable
+*
+* @param location - Location string from stack frame
+* @returns Object with filename, abs_path, and optional lineno/colno, or null if unparseable
+*/
+function parseLocation(location) {
+	if (location === "native") return {
+		filename: "native",
+		abs_path: "native"
+	};
+	if (location === "unknown location") return {
+		filename: "<unknown>",
+		abs_path: "<unknown>"
+	};
+	if (location.startsWith("eval at ")) return parseEvalOrigin(location);
+	const match = location.match(LOCATION_WITH_LINE_COLUMN_REGEX);
+	if (match) {
+		const [, filename, lineStr, colStr] = match;
+		return {
+			filename: makeRelativePath(filename),
+			abs_path: filename,
+			lineno: Number.parseInt(lineStr, 10),
+			colno: Number.parseInt(colStr, 10)
+		};
+	}
+	return null;
+}
+/**
+* Recursively unwraps eval location chains to extract the underlying file location.
+*
+* Eval locations have the format: "eval at functionName (location), <anonymous>:line:col"
+* where location can be another eval or a file location.
+*
+* V8 formats:
+* - "eval at Bar.z (myscript.js:10:3)" → extract myscript.js:10:3
+* - "eval at Foo (eval at Bar (file.js:10:3)), <anonymous>:5:2" → extract file.js:10:3
+*
+* @param evalLocation - Eval location string starting with "eval at "
+* @returns Object with extracted file location, or null if unparseable
+*/
+function parseEvalOrigin(evalLocation) {
+	let evalChainPart = evalLocation;
+	const commaIndex = findCommaAfterBalancedParens(evalLocation);
+	if (commaIndex !== -1) evalChainPart = evalLocation.slice(0, commaIndex);
+	const innerLocation = extractTrailingParenthesizedContent(evalChainPart);
+	if (!(innerLocation && evalChainPart.startsWith("eval at "))) return null;
+	if (innerLocation.startsWith("eval at ")) return parseEvalOrigin(innerLocation);
+	const locationMatch = innerLocation.match(LOCATION_WITH_LINE_COLUMN_REGEX);
+	if (locationMatch) {
+		const [, filename, lineStr, colStr] = locationMatch;
+		return {
+			filename: makeRelativePath(filename),
+			abs_path: filename,
+			lineno: Number.parseInt(lineStr, 10),
+			colno: Number.parseInt(colStr, 10)
+		};
+	}
+	return null;
+}
+/**
+* Finds the index of the comma that appears after balanced parentheses.
+*
+* For "eval at f (eval at g (x)), <anonymous>:1:2", returns the index of the comma
+* after the closing ")" and before "<anonymous>".
+*
+* @param str - String to search
+* @returns Index of comma, or -1 if not found
+*/
+function findCommaAfterBalancedParens(str) {
+	let depth = 0;
+	let foundOpenParen = false;
+	for (let i = 0; i < str.length; i++) if (str[i] === "(") {
+		depth++;
+		foundOpenParen = true;
+	} else if (str[i] === ")") {
+		depth--;
+		if (depth === 0 && foundOpenParen) {
+			for (let j = i + 1; j < str.length; j++) {
+				if (str[j] === ",") return j;
+				if (str[j] !== " ") return -1;
+			}
+			return -1;
+		}
+	}
+	return -1;
+}
+function extractTrailingParenthesizedContent(value) {
+	const trimmedValue = value.trim();
+	if (!trimmedValue.endsWith(")")) return null;
+	const openingParenIndex = findMatchingOpeningParen(trimmedValue);
+	if (openingParenIndex === -1) return null;
+	return trimmedValue.slice(openingParenIndex + 1, -1);
+}
+function findMatchingOpeningParen(value) {
+	let depth = 0;
+	for (let index = value.length - 1; index >= 0; index--) {
+		const char = value[index];
+		if (char === ")") depth++;
+		else if (char === "(") {
+			depth--;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+/**
+* Parses a single V8 stack frame line into a StackFrame object.
+*
+* Handles multiple V8 stack frame formats:
+* - "at functionName (filename:line:col)"
+* - "at filename:line:col" (top-level code)
+* - "at async functionName (filename:line:col)"
+* - "at Object.method (filename:line:col)"
+* - "at Module._compile (node:internal/...)" (internal modules)
+* - "at functionName (eval at ...)" (eval'd code)
+* - "at functionName (native)" (native code)
+*
+* @param line - Single line from V8 stack trace (trimmed, starts with "at ")
+* @returns Parsed StackFrame or null if line cannot be parsed
+*/
+function parseV8StackFrame(line) {
+	const withoutAt = line.slice(3);
+	const location = extractTrailingParenthesizedContent(withoutAt);
+	if (location) {
+		const openingParenIndex = findMatchingOpeningParen(withoutAt.trim());
+		const functionName = withoutAt.slice(0, openingParenIndex).trim();
+		const parsedLocation = parseLocation(location);
+		if (functionName && parsedLocation) return {
+			function: functionName,
+			filename: parsedLocation.filename,
+			abs_path: parsedLocation.abs_path,
+			lineno: parsedLocation.lineno,
+			colno: parsedLocation.colno,
+			in_app: isInApp(parsedLocation.abs_path)
+		};
+	}
+	const parsedLocation = parseLocation(withoutAt);
+	if (parsedLocation) return {
+		function: "<anonymous>",
+		filename: parsedLocation.filename,
+		abs_path: parsedLocation.abs_path,
+		lineno: parsedLocation.lineno,
+		colno: parsedLocation.colno,
+		in_app: isInApp(parsedLocation.abs_path)
+	};
+	return {
+		function: withoutAt,
+		filename: "<unknown>",
+		in_app: false
+	};
+}
+/**
+* Determines if a file path represents user code (in_app: true) or library code (in_app: false).
+*
+* Library code is identified by:
+* - Paths containing "/node_modules/"
+* - Node.js internal modules (e.g., "node:internal/...")
+* - Native code
+*
+* @param filename - File path from stack frame
+* @returns true if user code, false if library code
+*/
+function isInApp(filename) {
+	if (filename.includes("/node_modules/") || filename.includes("\\node_modules\\")) return false;
+	if (filename.startsWith("node:")) return false;
+	if (filename === "native" || filename === "<unknown>") return false;
+	return true;
+}
+/**
+* Normalizes URL schemes to regular file paths.
+*
+* Handles file:// URLs commonly seen in ESM modules and local testing:
+* - "file:///Users/john/project/src/index.ts" → "/Users/john/project/src/index.ts"
+* - "file:///C:/projects/app/src/index.ts" → "C:/projects/app/src/index.ts"
+*
+* @param filename - File path that may be a file:// URL
+* @returns Clean file path without URL scheme
+*/
+function normalizeUrl(filename) {
+	if (filename.startsWith("file://")) {
+		let result = filename.slice(7);
+		if (!(result.startsWith("/") || WINDOWS_DRIVE_PREFIX_REGEX.test(result))) result = `/${result}`;
+		return result;
+	}
+	return filename;
+}
+/**
+* Normalizes Node.js internal module paths for consistent error grouping.
+*
+* Examples:
+* - "node:internal/modules/cjs/loader" → "node:internal"
+* - "node:fs/promises" → "node:fs"
+* - "node:fs" → "node:fs" (unchanged)
+*
+* @param filename - File path that may be a Node.js internal module
+* @returns Simplified module path or original filename
+*/
+function normalizeNodeInternals(filename) {
+	if (filename.startsWith("node:internal")) return "node:internal";
+	if (filename.startsWith("node:")) return filename.split("/")[0];
+	return filename;
+}
+/**
+* Strips user-specific and system path prefixes.
+*
+* Removes prefixes like:
+* - /Users/username/ → ~/
+* - /home/username/ → ~/
+* - C:\Users\username\ → ~\
+* - C:/Users/username/ → ~/ (mixed separators)
+*
+* @param path - File path to normalize
+* @returns Path with system prefixes removed
+*/
+function stripSystemPrefixes(path) {
+	let result = path;
+	result = result.replace(UNIX_USER_HOME_REGEX, "~/");
+	result = result.replace(LINUX_USER_HOME_REGEX, "~/");
+	result = result.replace(WINDOWS_USER_HOME_REGEX, "~/");
+	return result;
+}
+/**
+* Normalizes node_modules paths to be consistent across deployments.
+*
+* Extracts only the package-relative portion of the path:
+* - /Users/john/project/node_modules/express/lib/router.js → node_modules/express/lib/router.js
+* - /app/node_modules/@scope/pkg/index.js → node_modules/@scope/pkg/index.js
+*
+* @param path - File path that may contain node_modules
+* @returns Normalized node_modules path or original path
+*/
+function normalizeNodeModules(path) {
+	const unixIndex = path.lastIndexOf("/node_modules/");
+	const winIndex = path.lastIndexOf("\\node_modules\\");
+	if (unixIndex !== -1) return path.slice(unixIndex + 1);
+	if (winIndex !== -1) return path.slice(winIndex + 1).replace(/\\/g, "/");
+	return path;
+}
+/**
+* Strips common deployment-specific path prefixes.
+*
+* Removes prefixes like:
+* - /var/www/app/ → ""
+* - /app/ → ""
+* - /opt/project/ → ""
+* - /var/task/ → "" (AWS Lambda)
+* - /usr/src/app/ → "" (Docker)
+*
+* @param path - File path to normalize
+* @returns Path with deployment prefixes removed
+*/
+function stripDeploymentPaths(path) {
+	let result = path;
+	for (const prefix of DEPLOYMENT_PREFIX_REGEXES) result = result.replace(prefix, "");
+	return result;
+}
+/**
+* Finds project-relative path using common project boundary markers.
+*
+* Looks for markers like /src/, /lib/, /dist/, /build/ and extracts the path
+* from that marker onwards:
+* - /Users/john/project/src/components/Button.tsx → src/components/Button.tsx
+* - /app/dist/index.js → dist/index.js
+*
+* Priority order: looks for primary markers first (src, lib, dist, build),
+* then secondary markers. Uses the highest-priority marker found.
+*
+* @param path - File path to search for project boundaries
+* @returns Project-relative path or original path if no marker found
+*/
+function findProjectPath(path) {
+	const primaryMarkers = [
+		"/src/",
+		"/lib/",
+		"/dist/",
+		"/build/"
+	];
+	const secondaryMarkers = [
+		"/app/",
+		"/components/",
+		"/pages/",
+		"/api/",
+		"/utils/",
+		"/services/",
+		"/modules/"
+	];
+	for (const marker of primaryMarkers) {
+		const index = path.lastIndexOf(marker);
+		if (index !== -1) return path.slice(index + 1);
+	}
+	for (const marker of secondaryMarkers) {
+		const index = path.lastIndexOf(marker);
+		if (index !== -1) return path.slice(index + 1);
+	}
+	return path;
+}
+/**
+* Converts absolute file paths to normalized relative paths for consistent error grouping.
+*
+* This function performs comprehensive path normalization to ensure errors from the same
+* code location group together regardless of deployment environment, user directories,
+* or system-specific paths. The original absolute path is always preserved in abs_path.
+*
+* Normalization steps:
+* 1. Normalize URL schemes (file://, etc.) - must be first to strip URL prefixes
+* 2. Preserve special paths (already relative, Node internals, etc.)
+* 3. Normalize path separators to forward slashes (for consistent processing)
+* 4. Normalize Node.js internal modules (node:internal/*, node:fs/*)
+* 5. Normalize node_modules paths to package-relative format
+* 6. Strip user home directories (/Users/*, /home/*, C:\Users\*)
+* 7. Strip deployment-specific paths (/var/www/*, /app/, AWS Lambda, Docker)
+* 8. Strip current working directory
+* 9. Find project boundaries (/src/, /lib/, /dist/, etc.)
+* 10. Remove leading slashes for clean relative paths
+*
+* @param filename - Absolute or relative file path from stack trace
+* @returns Normalized relative path for error grouping
+*
+* @example
+* makeRelativePath('/Users/john/project/src/index.ts')
+* // Returns: 'src/index.ts'
+*
+* @example
+* makeRelativePath('/home/ubuntu/app/node_modules/express/lib/router.js')
+* // Returns: 'node_modules/express/lib/router.js'
+*
+* @example
+* makeRelativePath('/var/www/myapp/dist/server.js')
+* // Returns: 'dist/server.js'
+*
+* @example
+* makeRelativePath('node:internal/modules/cjs/loader')
+* // Returns: 'node:internal'
+*
+* @example
+* makeRelativePath('C:\\Users\\John\\projects\\myapp\\src\\index.ts')
+* // Returns: 'src/index.ts'
+*/
+function makeRelativePath(filename) {
+	let result = filename;
+	result = normalizeUrl(result);
+	if (!(result.startsWith("/") || WINDOWS_ABSOLUTE_PATH_REGEX.test(result))) {
+		if (result.startsWith("node:")) return normalizeNodeInternals(result);
+		return result;
+	}
+	result = result.replace(/\\/g, "/");
+	if (result.startsWith("node:")) return normalizeNodeInternals(result);
+	if (result.includes("/node_modules/")) return normalizeNodeModules(result);
+	result = stripSystemPrefixes(result);
+	result = stripDeploymentPaths(result);
+	let cwd = null;
+	try {
+		if (typeof process !== "undefined" && typeof process.cwd === "function") cwd = process.cwd();
+	} catch {}
+	if (cwd && result.startsWith(cwd)) result = result.slice(cwd.length + 1);
+	if (result.startsWith("/") || WINDOWS_ABSOLUTE_SLASH_PATH_REGEX.test(result)) result = findProjectPath(result);
+	else if (result.startsWith("~")) {
+		const absoluteWithoutTilde = `/${result.slice(2)}`;
+		const projectPath = findProjectPath(absoluteWithoutTilde);
+		if (projectPath !== absoluteWithoutTilde) result = projectPath;
+	}
+	if (result.startsWith("/")) result = result.slice(1);
+	return result;
+}
+/**
+* Recursively unwraps Error.cause chain and returns array of chained errors.
+*
+* Error.cause is a standard JavaScript feature that allows chaining errors:
+*   const cause = new Error("Root cause");
+*   const error = new Error("Wrapper error", { cause });
+*
+* This function extracts all errors in the cause chain up to MAX_EXCEPTION_CHAIN_DEPTH.
+*
+* @param error - Error object to unwrap
+* @returns Array of ChainedErrorData objects representing the error chain
+*/
+function unwrapErrorCauses(error) {
+	const chainedErrors = [];
+	const seenErrors = /* @__PURE__ */ new Set();
+	let currentError = error.cause;
+	let depth = 0;
+	while (currentError && depth < MAX_EXCEPTION_CHAIN_DEPTH) {
+		if (!(currentError instanceof Error)) {
+			chainedErrors.push({
+				message: stringifyNonError(currentError),
+				type: void 0
+			});
+			break;
+		}
+		if (seenErrors.has(currentError)) break;
+		seenErrors.add(currentError);
+		const chainedErrorData = {
+			message: currentError.message || "",
+			type: currentError.name || currentError.constructor?.name || "Error"
+		};
+		if (currentError.stack) {
+			chainedErrorData.stack = currentError.stack;
+			chainedErrorData.frames = parseV8StackTrace(currentError.stack);
+		}
+		chainedErrors.push(chainedErrorData);
+		currentError = currentError.cause;
+		depth++;
+	}
+	return chainedErrors;
+}
+/**
+* Detects if a value is a CallToolResult object (SDK 1.21.0+ error format).
+*
+* SDK 1.21.0+ converts errors to CallToolResult format:
+* { content: [{ type: "text", text: "error message" }], isError: true }
+*
+* @param value - Value to check
+* @returns True if value is a CallToolResult object
+*/
+function isCallToolResult(value) {
+	return value !== null && typeof value === "object" && "isError" in value && "content" in value && Array.isArray(value.content);
+}
+function isTextContentPart(value) {
+	if (value === null || typeof value !== "object") return false;
+	const contentPart = value;
+	return contentPart.type === "text" && typeof contentPart.text === "string";
+}
+/**
+* Extracts error information from CallToolResult objects.
+*
+* SDK 1.21.0+ converts errors to CallToolResult, losing original stack traces.
+* This extracts the error message from the content array.
+*
+* @param result - CallToolResult object with error
+* @param _contextStack - Optional Error object for stack context (unused, kept for compatibility)
+* @returns ErrorData with extracted message (no stack trace)
+*/
+function captureCallToolResultError(result, _contextStack) {
+	return {
+		message: result.content.filter(isTextContentPart).map((contentPart) => contentPart.text).join(" ").trim() || "Unknown error",
+		type: void 0,
+		platform: "javascript"
+	};
+}
+/**
+* Converts non-Error objects to string representation for error messages.
+*
+* In JavaScript, anything can be thrown (not just Error objects):
+*   throw "string error";
+*   throw { code: 404 };
+*   throw null;
+*
+* This function handles these cases by converting them to meaningful strings.
+*
+* @param value - Non-Error value that was thrown
+* @returns String representation of the value
+*/
+function stringifyNonError(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region src/modules/context-parameters.ts
+function isContextEnabled(context) {
+	return context !== false;
+}
+function getContextDescription(context) {
+	return typeof context === "object" ? context.description : void 0;
+}
+/**
+* Adds a context parameter to a tool's JSON Schema.
+* This function is called AFTER the MCP SDK has converted Zod schemas to JSON Schema,
+* so we only need to handle JSON Schema format.
+*
+* Skips injection (with warning) for:
+* - Tools that already have a 'context' parameter
+* - Complex schemas (oneOf/allOf/anyOf) that can't safely have properties added
+* - Schemas with additionalProperties: false
+*/
+function addContextParameterToTool(tool, contextDescriptionOverride) {
+	const modifiedTool = { ...tool };
+	const toolName = tool.name || "unknown";
+	const schema = modifiedTool.inputSchema;
+	if (schema?.properties?.context) {
+		writeToLog(`WARN: Tool "${toolName}" already has 'context' parameter. Skipping context injection.`);
+		return modifiedTool;
+	}
+	if (schema?.oneOf || schema?.allOf || schema?.anyOf) {
+		writeToLog(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf). Skipping context injection.`);
+		return modifiedTool;
+	}
+	if (!modifiedTool.inputSchema) modifiedTool.inputSchema = {
+		type: "object",
+		properties: {},
+		required: []
+	};
+	const contextDescription = contextDescriptionOverride || DEFAULT_CONTEXT_PARAMETER_DESCRIPTION;
+	modifiedTool.inputSchema = JSON.parse(JSON.stringify(modifiedTool.inputSchema));
+	const inputSchema = modifiedTool.inputSchema;
+	if (!inputSchema.properties) inputSchema.properties = {};
+	if (inputSchema.additionalProperties === false) inputSchema.additionalProperties = void 0;
+	inputSchema.properties.context = {
+		type: "string",
+		description: contextDescription
+	};
+	if (Array.isArray(inputSchema.required)) {
+		if (!inputSchema.required.includes("context")) inputSchema.required.push("context");
+	} else inputSchema.required = ["context"];
+	return modifiedTool;
+}
+function addContextParameterToTools(tools, contextDescriptionOverride) {
+	return tools.map((tool) => {
+		if (tool.name === "get_more_tools") return tool;
+		return addContextParameterToTool(tool, contextDescriptionOverride);
+	});
+}
+//#endregion
+//#region src/modules/tools.ts
+const GET_MORE_TOOLS_NAME = "get_more_tools";
+function getReportMissingToolDescriptor() {
+	return {
+		name: GET_MORE_TOOLS_NAME,
+		description: "Check for additional tools whenever your task might benefit from specialized capabilities - even if existing tools could work as a fallback.",
+		inputSchema: {
+			type: "object",
+			properties: { context: {
+				type: "string",
+				description: "A description of your goal and what kind of tool would help accomplish it."
+			} },
+			required: ["context"]
+		}
+	};
+}
+function handleReportMissing(args) {
+	writeToLog(`Missing tool reported: ${JSON.stringify(args)}`);
+	return { content: [{
+		type: "text",
+		text: "Unfortunately, we have shown you the full tool list. We have noted your feedback and will work to improve the tool list in the future."
+	}] };
+}
+function setupMCPAnalyticsTools(server) {
+	const handlers = server._requestHandlers;
+	const originalListToolsHandler = handlers.get("tools/list");
+	const originalCallToolHandler = handlers.get("tools/call");
+	if (!(originalListToolsHandler && originalCallToolHandler)) {
+		writeToLog("Warning: Original tool handlers not found. Your tools may not be setup before PostHog MCP analytics .track().");
+		return;
+	}
+	try {
+		server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+			let tools = [];
+			const data = getServerTrackingData(server);
+			const event = {
+				sessionId: getServerSessionId(server, extra),
+				parameters: {
+					request,
+					extra
+				},
+				eventType: MCPAnalyticsEventType.mcpToolsList,
+				timestamp: /* @__PURE__ */ new Date(),
+				redactionFn: data?.options.redactSensitiveInformation
+			};
+			try {
+				tools = (await originalListToolsHandler(request, extra)).tools || [];
+			} catch (error) {
+				writeToLog(`Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`);
+				event.error = { message: getMCPCompatibleErrorMessage(error) };
+				event.isError = true;
+				event.duration = event.timestamp && Date.now() - event.timestamp.getTime() || 0;
+				publishEvent(server, event);
+				throw error;
+			}
+			if (!data) {
+				writeToLog("Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called track(server, options) before using tool calls.");
+				return { tools };
+			}
+			if (tools.length === 0) {
+				writeToLog("Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.track().");
+				event.error = { message: "No tools were sent to MCP client." };
+				event.isError = true;
+				event.duration = event.timestamp && Date.now() - event.timestamp.getTime() || 0;
+				publishEvent(server, event);
+				return { tools };
+			}
+			if (isContextEnabled(data.options.context)) tools = addContextParameterToTools(tools, getContextDescription(data.options.context));
+			if (data.options.reportMissing) {
+				if (!tools.some((tool) => tool?.name === "get_more_tools")) tools.push(getReportMissingToolDescriptor());
+			}
+			event.response = { tools };
+			event.isError = false;
+			event.duration = event.timestamp && Date.now() - event.timestamp.getTime() || 0;
+			publishEvent(server, event);
+			return { tools };
+		});
+	} catch (error) {
+		writeToLog(`Warning: Failed to override list tools handler - ${error}`);
+	}
+}
+//#endregion
+//#region src/modules/tracing.ts
+function isToolResultError$1(result) {
+	return !!result && typeof result === "object" && "isError" in result && result.isError === true;
+}
+const listToolsTracingSetup = /* @__PURE__ */ new WeakMap();
+function setupListToolsTracing(highLevelServer) {
+	const server = highLevelServer.server;
+	if (!server._capabilities?.tools) return;
+	if (listToolsTracingSetup.get(server)) return;
+	const originalListToolsHandler = server._requestHandlers.get("tools/list");
+	if (!originalListToolsHandler) return;
+	try {
+		server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => await handleListToolsRequest(server, originalListToolsHandler, request, extra));
+		listToolsTracingSetup.set(server, true);
+	} catch (error) {
+		writeToLog(`Warning: Failed to override list tools handler - ${error}`);
+	}
+}
+async function handleListToolsRequest(server, originalListToolsHandler, request, extra) {
+	const data = getServerTrackingData(server);
+	const event = {
+		sessionId: getServerSessionId(server, extra),
+		parameters: buildCapturedMcpParameters(request),
+		eventType: MCPAnalyticsEventType.mcpToolsList,
+		timestamp: /* @__PURE__ */ new Date(),
+		redactionFn: data?.options.redactSensitiveInformation
+	};
+	if (data) await applyResolvedMetadata$1(event, data, request, extra);
+	const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event);
+	if (!data) {
+		writeToLog("Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called track(server, options) before using tool calls.");
+		return { tools };
+	}
+	if (tools.length === 0) {
+		writeToLog("Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.track().");
+		event.error = { message: "No tools were sent to MCP client." };
+		event.isError = true;
+		event.duration = getEventDuration(event);
+		publishEvent(server, event);
+		return { tools };
+	}
+	event.response = { tools };
+	event.isError = false;
+	event.duration = getEventDuration(event);
+	publishEvent(server, event);
+	return { tools };
+}
+async function getTracedToolsList(server, originalListToolsHandler, request, extra, event) {
+	try {
+		const data = getServerTrackingData(server);
+		let tools = (await originalListToolsHandler(request, extra)).tools || [];
+		if (data && isContextEnabled(data.options.context)) tools = addContextParameterToTools(tools, getContextDescription(data.options.context));
+		if (data?.options.reportMissing) {
+			if (!tools.some((tool) => tool?.name === "get_more_tools")) tools.push(getReportMissingToolDescriptor());
+		}
+		return tools;
+	} catch (error) {
+		writeToLog(`Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`);
+		event.error = { message: getMCPCompatibleErrorMessage(error) };
+		event.isError = true;
+		event.duration = getEventDuration(event);
+		publishEvent(server, event);
+		throw error;
+	}
+}
+function setupInitializeTracing(highLevelServer) {
+	const server = highLevelServer.server;
+	const originalInitializeHandler = server._requestHandlers.get("initialize");
+	if (originalInitializeHandler) server.setRequestHandler(InitializeRequestSchema, async (request, extra) => {
+		const data = getServerTrackingData(server);
+		if (!data) {
+			writeToLog("Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called track(server, options) before using tool calls.");
+			return await originalInitializeHandler(request, extra);
+		}
+		const sessionId = getServerSessionId(server, extra);
+		await handleIdentify(server, data, request, extra);
+		const event = {
+			sessionId,
+			resourceName: request.params?.name || "Unknown Tool Name",
+			eventType: MCPAnalyticsEventType.mcpInitialize,
+			parameters: buildCapturedMcpParameters(request),
+			timestamp: /* @__PURE__ */ new Date(),
+			redactionFn: data.options.redactSensitiveInformation
+		};
+		const resolvedTags = await resolveEventTags(data, request, extra);
+		if (resolvedTags) event.tags = resolvedTags;
+		const resolvedProperties = await resolveEventProperties(data, request, extra);
+		if (resolvedProperties) event.properties = resolvedProperties;
+		const result = await originalInitializeHandler(request, extra);
+		event.response = result;
+		publishEvent(server, event);
+		return result;
+	});
+}
+function setupToolCallTracing(server) {
+	try {
+		const handlers = server._requestHandlers;
+		const originalCallToolHandler = handlers.get("tools/call");
+		const originalInitializeHandler = handlers.get("initialize");
+		if (originalInitializeHandler) server.setRequestHandler(InitializeRequestSchema, async (request, extra) => {
+			const data = getServerTrackingData(server);
+			if (!data) {
+				writeToLog("Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called track(server, options) before using tool calls.");
+				return await originalInitializeHandler(request, extra);
+			}
+			const sessionId = getServerSessionId(server, extra);
+			await handleIdentify(server, data, request, extra);
+			const event = {
+				sessionId,
+				resourceName: request.params?.name || "Unknown Tool Name",
+				eventType: MCPAnalyticsEventType.mcpInitialize,
+				parameters: buildCapturedMcpParameters(request),
+				timestamp: /* @__PURE__ */ new Date(),
+				redactionFn: data.options.redactSensitiveInformation
+			};
+			const resolvedTags = await resolveEventTags(data, request, extra);
+			if (resolvedTags) event.tags = resolvedTags;
+			const resolvedProperties = await resolveEventProperties(data, request, extra);
+			if (resolvedProperties) event.properties = resolvedProperties;
+			const result = await originalInitializeHandler(request, extra);
+			event.response = result;
+			publishEvent(server, event);
+			return result;
+		});
+		server.setRequestHandler(CallToolRequestSchema, async (request, extra) => await handleToolCallRequest(server, originalCallToolHandler, request, extra));
+	} catch (error) {
+		writeToLog(`Warning: Failed to setup tool call tracing - ${error}`);
+		throw error;
+	}
+}
+async function handleToolCallRequest(server, originalCallToolHandler, request, extra) {
+	const data = getServerTrackingData(server);
+	if (!data) {
+		writeToLog("Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called track(server, options) before using tool calls.");
+		return await originalCallToolHandler?.(request, extra);
+	}
+	const event = {
+		sessionId: getServerSessionId(server, extra),
+		resourceName: request.params?.name || "Unknown Tool Name",
+		parameters: buildCapturedMcpParameters(request),
+		eventType: MCPAnalyticsEventType.mcpToolsCall,
+		timestamp: /* @__PURE__ */ new Date(),
+		redactionFn: data.options.redactSensitiveInformation
+	};
+	try {
+		await handleIdentify(server, data, request, extra);
+		await applyResolvedMetadata$1(event, data, request, extra);
+		setToolCallContext(event, data.options.context, request);
+		const result = await executeToolCall(server, originalCallToolHandler, request, extra, event);
+		if (isToolResultError$1(result)) {
+			event.isError = true;
+			event.error = captureException(result);
+		}
+		event.response = result;
+		publishEvent(server, event);
+		return result;
+	} catch (error) {
+		event.isError = true;
+		event.error = captureException(error);
+		publishEvent(server, event);
+		throw error;
+	}
+}
+async function executeToolCall(server, originalCallToolHandler, request, extra, event) {
+	if (request.params?.name === "get_more_tools") {
+		const context = getContextArgument$1(request) || "";
+		event.userIntent = context;
+		return handleReportMissing({ context });
+	}
+	if (originalCallToolHandler) return await originalCallToolHandler(request, extra);
+	event.isError = true;
+	event.error = { message: `Tool call handler not found for ${request.params?.name || "unknown"}` };
+	event.duration = getEventDuration(event) || void 0;
+	publishEvent(server, event);
+	throw new Error(`Unknown tool: ${request.params?.name || "unknown"}`);
+}
+async function applyResolvedMetadata$1(event, data, request, extra) {
+	const resolvedTags = await resolveEventTags(data, request, extra);
+	if (resolvedTags) event.tags = resolvedTags;
+	const resolvedProperties = await resolveEventProperties(data, request, extra);
+	if (resolvedProperties) event.properties = resolvedProperties;
+}
+function setToolCallContext(event, context, request) {
+	if (!(isContextEnabled(context) && request.params?.name !== "get_more_tools")) return;
+	const contextArgument = getContextArgument$1(request);
+	if (contextArgument) event.userIntent = contextArgument;
+}
+function getContextArgument$1(request) {
+	const context = request.params?.arguments?.context;
+	return typeof context === "string" ? context : void 0;
+}
+function getEventDuration(event) {
+	return event.timestamp ? Date.now() - event.timestamp.getTime() : 0;
+}
+//#endregion
+//#region src/modules/mcp-sdk-compat.ts
+/**
+* Returns the tool function (callback/handler) from a RegisteredTool.
+* Supports both MCP SDK 1.23- (callback) and 1.24+ (handler).
+*/
+function getToolFunction(tool) {
+	if ("handler" in tool && typeof tool.handler === "function") return tool.handler;
+	if ("callback" in tool && typeof tool.callback === "function") return tool.callback;
+	throw new Error("Tool has neither callback nor handler property");
+}
+/**
+* Returns the property key name used for the tool function ("callback" or "handler").
+* This preserves the original property name when wrapping tools.
+*/
+function getToolFunctionKey(tool) {
+	if ("handler" in tool && typeof tool.handler === "function") return "handler";
+	return "callback";
+}
+/**
+* Returns true if the tool has a callback or handler property.
+*/
+function hasToolFunction(tool) {
+	if (!tool || typeof tool !== "object") return false;
+	const t = tool;
+	return "handler" in t && typeof t.handler === "function" || "callback" in t && typeof t.callback === "function";
+}
+/**
+* Creates a new tool object with the wrapped function, preserving the original property name.
+* This ensures MCP SDK 1.24+ gets back a tool with "handler" and 1.23- gets "callback".
+*/
+function createWrappedTool(originalTool, wrappedFunction) {
+	const key = getToolFunctionKey(originalTool);
+	return {
+		...originalTool,
+		[key]: wrappedFunction
+	};
+}
+function isZ4Schema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	return !!schema._zod;
+}
+function getObjectShape(schema) {
+	if (!schema || typeof schema !== "object") return;
+	let rawShape;
+	if (isZ4Schema(schema)) rawShape = schema._zod?.def?.shape;
+	else {
+		const v3Schema = schema;
+		rawShape = v3Schema.shape ?? v3Schema._def?.shape;
+	}
+	if (!rawShape) return;
+	if (typeof rawShape === "function") try {
+		return rawShape();
+	} catch {
+		return;
+	}
+	return rawShape;
+}
+function getLiteralValue(schema) {
+	if (!schema || typeof schema !== "object") return;
+	if (isZ4Schema(schema)) {
+		const def = schema._zod?.def;
+		if (def?.value !== void 0) return def.value;
+		if (Array.isArray(def?.values) && def.values.length > 0) return def.values[0];
+	} else {
+		const def = schema._def;
+		if (def?.value !== void 0) return def.value;
+		if (Array.isArray(def?.values) && def.values.length > 0) return def.values[0];
+	}
+	const directValue = schema.value;
+	if (directValue !== void 0) return directValue;
+}
+//#endregion
+//#region src/modules/tracing-v2.ts
+const wrappedCallbacks = /* @__PURE__ */ new WeakMap();
+const MCP_ANALYTICS_PROCESSED = Symbol("__posthog_mcp_analytics_processed__");
+function isToolResultError(result) {
+	return !!result && typeof result === "object" && "isError" in result && result.isError === true;
+}
+function isCallbackUpdate(value) {
+	return !!value && typeof value === "object" && "callback" in value && typeof value.callback === "function";
+}
+function addTracingToToolRegistry(tools, server) {
+	return Object.fromEntries(Object.entries(tools).map(([name, tool]) => [name, addTracingToToolCallbackInternal(tool, name, server)]));
+}
+function setupListenerToRegisteredTools(server) {
+	try {
+		if (!getServerTrackingData(server.server)) {
+			writeToLog("Warning: Cannot setup listener - no tracking data found");
+			return;
+		}
+		const handler = {
+			set(target, property, value) {
+				try {
+					if (typeof property === "string" && value && typeof value === "object" && hasToolFunction(value)) {
+						if (value[MCP_ANALYTICS_PROCESSED]) {
+							writeToLog(`Tool ${String(property)} already processed, skipping proxy wrapping`);
+							return Reflect.set(target, property, value);
+						}
+						if (wrappedCallbacks.has(getToolFunction(value))) {
+							writeToLog(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
+							return Reflect.set(target, property, value);
+						}
+						const nextValue = addTracingToToolCallbackInternal(value, property, server);
+						setupListToolsTracing(server);
+						if (typeof nextValue.update === "function") {
+							const originalUpdate = nextValue.update;
+							nextValue.update = function(...updateArgs) {
+								if (updateArgs[0]) {
+									const updateObj = updateArgs[0];
+									if (isCallbackUpdate(updateObj)) updateObj.callback = getToolFunction(addTracingToToolCallbackInternal({ callback: updateObj.callback }, property, server));
+								}
+								return originalUpdate.apply(this, updateArgs);
+							};
+						}
+						return Reflect.set(target, property, nextValue);
+					}
+					return Reflect.set(target, property, value);
+				} catch (error) {
+					writeToLog(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
+					return Reflect.set(target, property, value);
+				}
+			},
+			get(target, property) {
+				return Reflect.get(target, property);
+			},
+			deleteProperty(target, property) {
+				return Reflect.deleteProperty(target, property);
+			},
+			has(target, property) {
+				return Reflect.has(target, property);
+			}
+		};
+		const originalTools = server._registeredTools || {};
+		server._registeredTools = new Proxy(originalTools, handler);
+		writeToLog("Successfully set up listener for new tool registrations");
+	} catch (error) {
+		writeToLog(`Warning: Failed to setup listener for registered tools - ${error}`);
+	}
+}
+function addTracingToToolCallbackInternal(tool, toolName, _server) {
+	const originalCallback = getToolFunction(tool);
+	if (wrappedCallbacks.has(originalCallback)) {
+		writeToLog(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
+		return tool;
+	}
+	if (tool[MCP_ANALYTICS_PROCESSED]) {
+		writeToLog(`Tool ${toolName} already processed, skipping re-wrap`);
+		return tool;
+	}
+	const wrappedCallback = async (...params) => {
+		let args;
+		let extra;
+		if (params.length === 2) {
+			args = params[0];
+			extra = params[1];
+		} else {
+			args = void 0;
+			extra = params[0];
+		}
+		const removeContextFromArgs = (args) => {
+			if (args && typeof args === "object" && "context" in args) {
+				const { context: _context, ...argsWithoutContext } = args;
+				return argsWithoutContext;
+			}
+			return args;
+		};
+		const cleanedArgs = toolName === "get_more_tools" ? args : removeContextFromArgs(args);
+		try {
+			if (cleanedArgs === void 0) return await originalCallback(extra);
+			return await originalCallback(cleanedArgs, extra);
+		} catch (error) {
+			if (error instanceof Error) extra.__mcp_analytics_error = error;
+			throw error;
+		}
+	};
+	wrappedCallbacks.set(originalCallback, true);
+	wrappedCallbacks.set(wrappedCallback, true);
+	const wrappedTool = createWrappedTool(tool, wrappedCallback);
+	wrappedTool[MCP_ANALYTICS_PROCESSED] = true;
+	return wrappedTool;
+}
+function setupToolsCallHandlerWrapping(server) {
+	const lowLevelServer = server.server;
+	const existingHandler = lowLevelServer._requestHandlers.get("tools/call");
+	if (existingHandler) {
+		const wrappedHandler = createToolsCallWrapper(existingHandler, lowLevelServer);
+		lowLevelServer._requestHandlers.set("tools/call", wrappedHandler);
+	}
+	const originalSetRequestHandler = lowLevelServer.setRequestHandler.bind(lowLevelServer);
+	lowLevelServer.setRequestHandler = ((requestSchema, handler) => {
+		const shape = getObjectShape(requestSchema);
+		if ((shape?.method ? getLiteralValue(shape.method) : void 0) === "tools/call") return originalSetRequestHandler(requestSchema, createToolsCallWrapper(handler, lowLevelServer));
+		return originalSetRequestHandler(requestSchema, handler);
+	});
+}
+function createToolsCallWrapper(originalHandler, server) {
+	return async (request, extra) => await handleWrappedToolsCall(originalHandler, server, request, extra);
+}
+async function handleWrappedToolsCall(originalHandler, server, request, extra) {
+	const startTime = /* @__PURE__ */ new Date();
+	const tracing = await initializeToolCallEvent(server, request, extra, startTime);
+	if (request?.params?.name === "get_more_tools") return await executeReportMissingTool(server, request, tracing, startTime);
+	return await executeOriginalTool(originalHandler, server, request, extra, tracing, startTime);
+}
+async function initializeToolCallEvent(server, request, extra, startTime) {
+	try {
+		const data = getServerTrackingData(server);
+		if (!data) {
+			writeToLog("Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called track(server, options) before using tool calls.");
+			return {
+				event: null,
+				shouldPublishEvent: false
+			};
+		}
+		const event = {
+			sessionId: getServerSessionId(server, extra),
+			resourceName: request.params?.name || "Unknown Tool",
+			parameters: buildCapturedMcpParameters(request),
+			eventType: MCPAnalyticsEventType.mcpToolsCall,
+			timestamp: startTime,
+			redactionFn: data.options.redactSensitiveInformation
+		};
+		await handleIdentify(server, data, request, extra);
+		event.sessionId = data.sessionId;
+		await applyResolvedMetadata(event, data, request, extra);
+		const contextArgument = getContextArgument(request);
+		if (isContextEnabled(data.options.context) && contextArgument) event.userIntent = contextArgument;
+		return {
+			event,
+			shouldPublishEvent: true
+		};
+	} catch (error) {
+		writeToLog(`Warning: PostHog MCP analytics tracing failed for tool ${request.params?.name}, falling back to original handler - ${error}`);
+		return {
+			event: null,
+			shouldPublishEvent: false
+		};
+	}
+}
+async function applyResolvedMetadata(event, data, request, extra) {
+	const resolvedTags = await resolveEventTags(data, request, extra);
+	if (resolvedTags) event.tags = resolvedTags;
+	const resolvedProperties = await resolveEventProperties(data, request, extra);
+	if (resolvedProperties) event.properties = resolvedProperties;
+}
+async function executeReportMissingTool(server, request, tracing, startTime) {
+	try {
+		const context = getContextArgument(request) || "";
+		const result = await handleReportMissing({ context });
+		publishSuccessfulToolEvent(server, tracing, result, startTime, { userIntent: context });
+		return result;
+	} catch (error) {
+		publishFailedToolEvent(server, tracing, error, startTime);
+		throw error;
+	}
+}
+async function executeOriginalTool(originalHandler, server, request, extra, tracing, startTime) {
+	try {
+		const result = await originalHandler(request, extra);
+		publishSuccessfulToolEvent(server, tracing, result, startTime, {
+			capturedError: extra?.__mcp_analytics_error,
+			clearCapturedError: () => {
+				if (extra) extra.__mcp_analytics_error = void 0;
+			}
+		});
+		return result;
+	} catch (error) {
+		publishFailedToolEvent(server, tracing, error, startTime);
+		throw error;
+	}
+}
+function getContextArgument(request) {
+	const context = request.params?.arguments?.context;
+	return typeof context === "string" ? context : void 0;
+}
+function publishSuccessfulToolEvent(server, tracing, result, startTime, options = {}) {
+	if (!(tracing.event && tracing.shouldPublishEvent)) return;
+	if (options.userIntent) tracing.event.userIntent = options.userIntent;
+	if (isToolResultError(result)) {
+		tracing.event.isError = true;
+		tracing.event.error = captureException(options.capturedError || result);
+		options.clearCapturedError?.();
+	}
+	tracing.event.response = result;
+	tracing.event.duration = Date.now() - startTime.getTime();
+	publishEvent(server, tracing.event);
+}
+function publishFailedToolEvent(server, tracing, error, startTime) {
+	if (!(tracing.event && tracing.shouldPublishEvent)) return;
+	tracing.event.isError = true;
+	tracing.event.error = captureException(error);
+	tracing.event.duration = Date.now() - startTime.getTime();
+	publishEvent(server, tracing.event);
+}
+function setupTracking(server) {
+	try {
+		getServerTrackingData(server.server);
+		setupToolsCallHandlerWrapping(server);
+		setupInitializeTracing(server);
+		server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
+		setupListToolsTracing(server);
+		setupListenerToRegisteredTools(server);
+	} catch (error) {
+		writeToLog(`Warning: Failed to setup tool call tracing - ${error}`);
+	}
+}
+//#endregion
+//#region src/index.ts
+/**
+* Integrates PostHog MCP into an MCP server to track tool usage patterns and user interactions.
+*
+* @param server - The MCP server instance to track. Must be a compatible MCP server implementation.
+* @param options - Configuration to customize tracking behavior.
+* @param options.apiKey - PostHog project API key (`phc_...`). Optional when using an injected `posthogClient`.
+* @param options.host - Custom PostHog ingestion host. Defaults to `https://us.i.posthog.com`.
+* @param options.reportMissing - Adds a "get_more_tools" tool that allows LLMs to automatically report missing functionality. Defaults to false.
+* @param options.enableAITracing - Emits `$ai_span` events for tool calls so MCP activity appears in PostHog LLM analytics. Defaults to false.
+* @param options.enableTracing - Enables tracking of tool calls and usage patterns.
+* @param options.context - Enables the required "context" parameter on tools to capture user intent. Pass false to disable, or an object with a custom description.
+* @param options.identify - Async function to identify users and attach custom data to their sessions.
+* @param options.redactSensitiveInformation - Function to redact sensitive data before sending to PostHog.
+* @param options.eventTags - Callback invoked on every auto-captured event (tool calls, tool lists, initialize) to attach string key-value tags. Tags are intended to be indexed and queryable in PostHog — use them for structured metadata you'll want to filter or group by (e.g., trace IDs, environments, regions). Tags are validated client-side: keys must be ≤32 chars matching `[a-zA-Z0-9$_.:\- ]`, values must be strings ≤200 chars with no newlines, max 50 entries per event. Invalid entries are silently dropped with a warning logged to `~/posthog-mcp-analytics.log`. If the callback throws or returns null, tags are omitted. Receives the same `(request, extra)` arguments as `identify`.
+* @param options.eventProperties - Callback invoked on every auto-captured event to attach flexible JSON metadata (device info, feature flags, nested context). No constraints beyond standard JSON types. If the callback throws or returns null, properties are omitted. Receives the same `(request, extra)` arguments as `identify`.
+* @param options.posthogClient - Optional existing posthog-node compatible client. If provided, MCP events are captured with that client instead of creating a new one.
+* @param options.posthogOptions - Optional posthog-node options used when the SDK creates its own client.
+*
+* @returns The tracked server instance.
+*
+* @remarks
+* Analytics data and debug information are logged to `~/posthog-mcp-analytics.log` since console logs interfere
+* with STDIO-based MCP servers.
+*
+* Do not call `track()` multiple times on the same server instance as this will cause unexpected behavior.
+*
+* @example
+* ```typescript
+* import { track } from "@posthog/mcp";
+*
+* const mcpServer = new Server({ name: "my-mcp-server", version: "1.0.0" });
+*
+* // Track the server with PostHog MCP
+* track(mcpServer, { apiKey: "phc_abc123xyz" });
+*
+* // Register your tools
+* mcpServer.setRequestHandler(ListToolsRequestSchema, async () => ({
+*   tools: [{ name: "my_tool", description: "Does something useful" }]
+* }));
+* ```
+*
+* @example
+* ```typescript
+* // With user identification
+* track(mcpServer, {
+*   apiKey: "phc_abc123xyz",
+*   identify: async (request, extra) => {
+*     const user = await getUserFromToken(request.params.arguments.token);
+*     return {
+*       userId: user.id,
+*       userData: { plan: user.plan, company: user.company }
+*     };
+*   }
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With custom context description
+* track(mcpServer, {
+*   apiKey: "phc_abc123xyz",
+*   context: {
+*     description: "Explain why you're calling this tool and what business objective it helps achieve"
+*   }
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With sensitive data redaction
+* track(mcpServer, {
+*   apiKey: "phc_abc123xyz",
+*   redactSensitiveInformation: async (text) => {
+*     return text.replace(/api_key_\w+/g, "[REDACTED]");
+*   }
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With event tags and properties
+* track(mcpServer, {
+*   apiKey: "phc_abc123xyz",
+*   eventTags: async (request, extra) => ({
+*     trace_id: extra?.requestContext?.traceId,
+*     env: process.env.NODE_ENV,
+*     region: "us-east-1",
+*   }),
+*   eventProperties: async (request, extra) => ({
+*     device: "desktop",
+*     app_version: "2.1.0",
+*     feature_flags: ["dark_mode", "beta_ui"],
+*   }),
+* });
+* ```
+*
+* @example
+* ```typescript
+*/
+function track(server, options = {}) {
+	try {
+		const validatedServer = isCompatibleServerType(server);
+		const lowLevelServer = getLowLevelServer(validatedServer);
+		configureIngestion(options);
+		if (getServerTrackingData(lowLevelServer)) {
+			writeToLog("[SESSION DEBUG] track() - Server already being tracked, skipping initialization");
+			return validatedServer;
+		}
+		if (!(options.apiKey || options.posthogClient)) writeToLog("Warning: No PostHog API key or PostHog client configured. Events will not be sent anywhere.");
+		const mcpAnalyticsData = buildTrackingData(lowLevelServer, options);
+		setServerTrackingData(lowLevelServer, mcpAnalyticsData);
+		setupTrackedServer(validatedServer, lowLevelServer, mcpAnalyticsData);
+		return validatedServer;
+	} catch (error) {
+		writeToLog(`Warning: Failed to track server - ${error}`);
+		return server;
+	}
+}
+function getLowLevelServer(server) {
+	return isHighLevelServer(server) ? server.server : server;
+}
+function configureIngestion(options) {
+	const host = options.host || process.env.POSTHOG_MCP_ANALYTICS_HOST;
+	if (options.posthogOptions) eventQueue.configurePostHogOptions(options.posthogOptions);
+	if (host) eventQueue.configure(host);
+}
+function buildTrackingData(lowLevelServer, options) {
+	return {
+		apiKey: options.apiKey || "",
+		sessionId: newSessionId(),
+		lastActivity: /* @__PURE__ */ new Date(),
+		identifiedSessions: /* @__PURE__ */ new Map(),
+		sessionInfo: getSessionInfo(lowLevelServer, void 0),
+		options: {
+			reportMissing: options.reportMissing ?? false,
+			enableAITracing: options.enableAITracing ?? false,
+			enableTracing: options.enableTracing ?? true,
+			context: options.context,
+			identify: options.identify,
+			redactSensitiveInformation: options.redactSensitiveInformation,
+			eventTags: options.eventTags,
+			eventProperties: options.eventProperties,
+			host: options.host,
+			posthogClient: options.posthogClient,
+			posthogOptions: options.posthogOptions
+		},
+		sessionSource: "generated"
+	};
+}
+function setupTrackedServer(validatedServer, lowLevelServer, mcpAnalyticsData) {
+	if (isHighLevelServer(validatedServer)) setupTracking(validatedServer);
+	else {
+		if (mcpAnalyticsData.options.reportMissing) try {
+			setupMCPAnalyticsTools(lowLevelServer);
+		} catch (error) {
+			writeToLog(`Warning: Failed to setup report missing tool - ${error}`);
+		}
+		if (mcpAnalyticsData.options.enableTracing) try {
+			setupToolCallTracing(lowLevelServer);
+		} catch (error) {
+			writeToLog(`Warning: Failed to setup tool call tracing - ${error}`);
+		}
+	}
+}
+/**
+* Publishes a custom event to PostHog MCP with flexible session management.
+*
+* @param serverOrSessionId - Either a tracked MCP server instance or a MCP session ID string
+* @param eventData - Event data to include with the custom event. `apiKey` is required when publishing against a raw session ID.
+*
+* @returns Promise that resolves when the event is queued for publishing
+*
+* @example
+* ```typescript
+* // With a tracked server
+* await publishCustomEvent(
+*   server,
+*   {
+*     resourceName: "custom-action",
+*     parameters: { action: "user-feedback", rating: 5 },
+*     message: "User provided feedback"
+*   }
+* );
+* ```
+*
+* @example
+* ```typescript
+* // With a MCP session ID
+* await publishCustomEvent(
+*   "user-session-12345",
+*   {
+*     apiKey: "phc_abc123xyz",
+*     isError: true,
+*     error: { message: "Custom error occurred", code: "ERR_001" }
+*   }
+* );
+* ```
+*
+* @example
+* ```typescript
+* await publishCustomEvent(
+*   server,
+*   {
+*     resourceName: "feature-usage",
+*   }
+* );
+* ```
+*/
+function publishCustomEvent(serverOrSessionId, eventData = {}) {
+	try {
+		publishCustomEventSync(serverOrSessionId, eventData);
+		return Promise.resolve();
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+function publishCustomEventSync(serverOrSessionId, eventData) {
+	const target = resolveCustomEventTarget(serverOrSessionId, eventData);
+	const event = {
+		sessionId: target.sessionId,
+		apiKey: target.apiKey,
+		eventType: MCPAnalyticsEventType.custom,
+		timestamp: /* @__PURE__ */ new Date(),
+		resourceName: eventData?.resourceName,
+		parameters: eventData?.parameters,
+		response: eventData?.response,
+		userIntent: eventData?.message,
+		duration: eventData?.duration,
+		isError: eventData?.isError,
+		error: resolveCustomEventError(eventData?.error)
+	};
+	if (eventData?.tags) event.tags = validateTags(eventData.tags);
+	if (eventData?.properties && Object.keys(eventData.properties).length > 0) event.properties = eventData.properties;
+	publishResolvedCustomEvent(target, event);
+	writeToLog(`Published custom event for session ${target.sessionId} with type '${MCPAnalyticsEventType.custom}'`);
+}
+function resolveCustomEventError(error) {
+	if (error === void 0 || error === null) return error;
+	if (typeof error === "object" && "message" in error && typeof error.message === "string") return error;
+	return captureException(error);
+}
+function resolveCustomEventTarget(serverOrSessionId, eventData) {
+	if (typeof serverOrSessionId === "string") return resolveSessionIdTarget(serverOrSessionId, eventData);
+	if (serverOrSessionId && typeof serverOrSessionId === "object") return resolveTrackedServerTarget(serverOrSessionId);
+	throw new Error("First parameter must be either an MCP server object or a session ID string");
+}
+function resolveSessionIdTarget(sessionIdInput, eventData) {
+	const apiKey = eventData.apiKey || "";
+	if (!(apiKey || eventData.posthogClient)) throw new Error("apiKey or posthogClient is required when publishing with a session ID");
+	return {
+		apiKey,
+		lowLevelServer: null,
+		posthogClient: eventData.posthogClient,
+		sessionId: deriveSessionIdFromMCPSession(sessionIdInput)
+	};
+}
+function resolveTrackedServerTarget(server) {
+	const lowLevelServer = getLowLevelServerFromUnknownObject(server);
+	const trackingData = getServerTrackingData(lowLevelServer);
+	if (!trackingData) throw new Error("Server is not tracked. Please call track() first or provide a session ID string.");
+	return {
+		apiKey: trackingData.apiKey,
+		lowLevelServer,
+		posthogClient: trackingData.options.posthogClient,
+		sessionId: trackingData.sessionId
+	};
+}
+function getLowLevelServerFromUnknownObject(server) {
+	return "server" in server && server.server && typeof server.server === "object" ? server.server : server;
+}
+function publishResolvedCustomEvent(target, event) {
+	if (target.lowLevelServer && getServerTrackingData(target.lowLevelServer)) {
+		publishEvent(target.lowLevelServer, event);
+		return;
+	}
+	if (target.posthogClient) {
+		eventQueue.add(event, target.posthogClient);
+		return;
+	}
+	eventQueue.add(event);
+}
+//#endregion
+export { PostHogMCPAnalyticsProperty, publishCustomEvent, track };
+
+//# sourceMappingURL=index.mjs.map