@savvly/mcp-server 1.0.20 → 1.0.21

package/dist/cli.js

@@ -2231,8 +2231,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize) {
-      if (normalize !== false)
+    function getFullPath(resolver, id = "", normalize2) {
+      if (normalize2 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -3628,7 +3628,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize(uri, options) {
+    function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         normalizeString(uri, options);
@@ -3895,7 +3895,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize,
+      normalize: normalize2,
       resolve,
       resolveComponent,
       equal,
@@ -11044,7 +11044,7 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   inst.element = def.element;
   inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
   inst.nonempty = (params) => inst.check(_minLength(1, params));
-  inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
+  inst.max = (maxLength2, params) => inst.check(_maxLength(maxLength2, params));
   inst.length = (len, params) => inst.check(_length(len, params));
   inst.unwrap = () => inst.element;
 });
@@ -14455,10 +14455,10 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
       ...errorUtil.errToObj(message)
     });
   }
-  max(maxLength, message) {
+  max(maxLength2, message) {
     return this._addCheck({
       kind: "max",
-      value: maxLength,
+      value: maxLength2,
       ...errorUtil.errToObj(message)
     });
   }
@@ -15322,10 +15322,10 @@ var ZodArray2 = class _ZodArray extends ZodType2 {
       minLength: { value: minLength, message: errorUtil.toString(message) }
     });
   }
-  max(maxLength, message) {
+  max(maxLength2, message) {
     return new _ZodArray({
       ...this._def,
-      maxLength: { value: maxLength, message: errorUtil.toString(message) }
+      maxLength: { value: maxLength2, message: errorUtil.toString(message) }
     });
   }
   length(len, message) {
@@ -21704,7 +21704,7 @@ var PRODUCT_COMPARISON = {
 var VALID_PRODUCT_TYPES = COMPARISONS.map((c) => c.product_type);
 
 // ../../src/mcp/version.ts
-var SERVER_VERSION = "1.0.20";
+var SERVER_VERSION = "1.0.21";
 
 // ../../src/mcp/ui/payout-chart.ts
 var PAYOUT_UI_URI = "ui://savvly/payout-chart.html";
@@ -24082,6 +24082,3827 @@ function wrapToolHandler(name, handler) {
 }
 var MAX_BODY_HASH_BYTES = 64 * 1024;
 
+// ../../node_modules/mcpcat/dist/index.mjs
+import { createRequire } from "module";
+
+// ../../node_modules/mcpcat-api/dist/esm/runtime.js
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var BASE_PATH = "http://localhost:8000".replace(/\/+$/, "");
+var Configuration = class {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return void 0;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : () => __awaiter(this, void 0, void 0, function* () {
+        return accessToken;
+      });
+    }
+    return void 0;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+};
+var DefaultConfig = new Configuration();
+var BaseAPI = class _BaseAPI {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.fetchApi = (url, init) => __awaiter(this, void 0, void 0, function* () {
+      let fetchParams = { url, init };
+      for (const middleware of this.middleware) {
+        if (middleware.pre) {
+          fetchParams = (yield middleware.pre(Object.assign({ fetch: this.fetchApi }, fetchParams))) || fetchParams;
+        }
+      }
+      let response = void 0;
+      try {
+        response = yield (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+      } catch (e) {
+        for (const middleware of this.middleware) {
+          if (middleware.onError) {
+            response = (yield middleware.onError({
+              fetch: this.fetchApi,
+              url: fetchParams.url,
+              init: fetchParams.init,
+              error: e,
+              response: response ? response.clone() : void 0
+            })) || response;
+          }
+        }
+        if (response === void 0) {
+          if (e instanceof Error) {
+            throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+          } else {
+            throw e;
+          }
+        }
+      }
+      for (const middleware of this.middleware) {
+        if (middleware.post) {
+          response = (yield middleware.post({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            response: response.clone()
+          })) || response;
+        }
+      }
+      return response;
+    });
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return _BaseAPI.jsonRegex.test(mime);
+  }
+  request(context, initOverrides) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const { url, init } = yield this.createFetchParams(context, initOverrides);
+      const response = yield this.fetchApi(url, init);
+      if (response && (response.status >= 200 && response.status < 300)) {
+        return response;
+      }
+      throw new ResponseError(response, "Response returned an error code");
+    });
+  }
+  createFetchParams(context, initOverrides) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let url = this.configuration.basePath + context.path;
+      if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+        url += "?" + this.configuration.queryParamsStringify(context.query);
+      }
+      const headers = Object.assign({}, this.configuration.headers, context.headers);
+      Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
+      const initOverrideFn = typeof initOverrides === "function" ? initOverrides : () => __awaiter(this, void 0, void 0, function* () {
+        return initOverrides;
+      });
+      const initParams = {
+        method: context.method,
+        headers,
+        body: context.body,
+        credentials: this.configuration.credentials
+      };
+      const overriddenInit = Object.assign(Object.assign({}, initParams), yield initOverrideFn({
+        init: initParams,
+        context
+      }));
+      let body;
+      if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+        body = overriddenInit.body;
+      } else if (this.isJsonMime(headers["Content-Type"])) {
+        body = JSON.stringify(overriddenInit.body);
+      } else {
+        body = overriddenInit.body;
+      }
+      const init = Object.assign(Object.assign({}, overriddenInit), { body });
+      return { url, init };
+    });
+  }
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+};
+BaseAPI.jsonRegex = new RegExp("^(:?application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(:?;.*)?$", "i");
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+    this.name = "ResponseError";
+  }
+};
+var FetchError = class extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+    this.name = "FetchError";
+  }
+};
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+var JSONApiResponse = class {
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  value() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.transformer(yield this.raw.json());
+    });
+  }
+};
+
+// ../../node_modules/mcpcat-api/dist/esm/models/EventAcceptedResponse.js
+function EventAcceptedResponseFromJSON(json) {
+  return EventAcceptedResponseFromJSONTyped(json, false);
+}
+function EventAcceptedResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "status": json["status"] == null ? void 0 : json["status"]
+  };
+}
+
+// ../../node_modules/mcpcat-api/dist/esm/models/PublishEventRequest.js
+var PublishEventRequestEventTypeEnum = {
+  mcpPing: "mcp:ping",
+  mcpInitialize: "mcp:initialize",
+  mcpCompletionComplete: "mcp:completion/complete",
+  mcpLoggingSetLevel: "mcp:logging/setLevel",
+  mcpPromptsGet: "mcp:prompts/get",
+  mcpPromptsList: "mcp:prompts/list",
+  mcpResourcesList: "mcp:resources/list",
+  mcpResourcesTemplatesList: "mcp:resources/templates/list",
+  mcpResourcesRead: "mcp:resources/read",
+  mcpResourcesSubscribe: "mcp:resources/subscribe",
+  mcpResourcesUnsubscribe: "mcp:resources/unsubscribe",
+  mcpToolsCall: "mcp:tools/call",
+  mcpToolsList: "mcp:tools/list",
+  mcpcatIdentify: "mcpcat:identify"
+};
+function PublishEventRequestToJSON(json) {
+  return PublishEventRequestToJSONTyped(json, false);
+}
+function PublishEventRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return Object.assign(Object.assign({}, value), { "id": value["id"], "project_id": value["projectId"], "session_id": value["sessionId"], "actor_id": value["actorId"], "event_id": value["eventId"], "event_type": value["eventType"], "is_error": value["isError"], "error": value["error"], "resource_name": value["resourceName"], "duration": value["duration"], "timestamp": value["timestamp"] == null ? void 0 : value["timestamp"].toISOString(), "user_intent": value["userIntent"], "parameters": value["parameters"], "response": value["response"], "identify_actor_given_id": value["identifyActorGivenId"], "identify_actor_name": value["identifyActorName"], "identify_data": value["identifyData"], "tags": value["tags"], "properties": value["properties"], "ip_address": value["ipAddress"], "sdk_language": value["sdkLanguage"], "mcpcat_version": value["mcpcatVersion"], "server_name": value["serverName"], "server_version": value["serverVersion"], "client_name": value["clientName"], "client_version": value["clientVersion"] });
+}
+
+// ../../node_modules/mcpcat-api/dist/esm/apis/EventsApi.js
+var __awaiter2 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var EventsApi = class extends BaseAPI {
+  /**
+   * Submit analytics events for a project. Returns immediately with 202 Accepted.
+   * Publish analytics event
+   */
+  publishEventRaw(requestParameters, initOverrides) {
+    return __awaiter2(this, void 0, void 0, function* () {
+      const queryParameters = {};
+      const headerParameters = {};
+      headerParameters["Content-Type"] = "application/json";
+      if (this.configuration && this.configuration.apiKey) {
+        headerParameters["Authorization"] = yield this.configuration.apiKey("Authorization");
+      }
+      let urlPath = `/v1/public/events/`;
+      const response = yield this.request({
+        path: urlPath,
+        method: "POST",
+        headers: headerParameters,
+        query: queryParameters,
+        body: PublishEventRequestToJSON(requestParameters["publishEventRequest"])
+      }, initOverrides);
+      return new JSONApiResponse(response, (jsonValue) => EventAcceptedResponseFromJSON(jsonValue));
+    });
+  }
+  /**
+   * Submit analytics events for a project. Returns immediately with 202 Accepted.
+   * Publish analytics event
+   */
+  publishEvent() {
+    return __awaiter2(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+      const response = yield this.publishEventRaw(requestParameters, initOverrides);
+      return yield response.value();
+    });
+  }
+};
+
+// ../../node_modules/mcpcat/dist/index.mjs
+import { randomBytes } from "crypto";
+import { inspect } from "util";
+import { promisify } from "util";
+import { createHash as createHash2 } from "crypto";
+import { createRequire as createRequire2 } from "module";
+import { createHash as createHash22, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
+var fsModule = null;
+var logFilePath = null;
+var initAttempted = false;
+var useConsoleFallback = false;
+function tryInitSync() {
+  if (initAttempted) return;
+  initAttempted = true;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const fs = require2("fs");
+    const os = require2("os");
+    const path = require2("path");
+    const home = os.homedir?.();
+    if (home) {
+      fsModule = fs;
+      logFilePath = path.join(home, "mcpcat.log");
+    } else {
+      useConsoleFallback = true;
+    }
+  } catch {
+    useConsoleFallback = true;
+    fsModule = null;
+    logFilePath = null;
+  }
+}
+function writeToLog(message) {
+  tryInitSync();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logEntry = `[${timestamp}] ${message}`;
+  if (useConsoleFallback) {
+    console.log(`[mcpcat] ${logEntry}`);
+    return;
+  }
+  if (!logFilePath || !fsModule) {
+    return;
+  }
+  try {
+    if (!fsModule.existsSync(logFilePath)) {
+      fsModule.writeFileSync(logFilePath, logEntry + "\n");
+    } else {
+      fsModule.appendFileSync(logFilePath, logEntry + "\n");
+    }
+  } catch {
+  }
+}
+function logCompatibilityWarning() {
+  writeToLog(
+    "MCPCat 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.server && typeof server.server === "object";
+}
+function isCompatibleServerType(server) {
+  if (!server || typeof server !== "object") {
+    logCompatibilityWarning();
+    throw new Error(
+      "MCPCat 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(
+        "MCPCat 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(
+        "MCPCat 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;
+  } else {
+    validateLowLevelServer(server);
+    return server;
+  }
+}
+function validateLowLevelServer(server) {
+  if (typeof server.setRequestHandler !== "function") {
+    logCompatibilityWarning();
+    throw new Error(
+      "MCPCat SDK compatibility error: Server must have a setRequestHandler method. This requires MCP SDK v1.11 or higher."
+    );
+  }
+  if (!server._requestHandlers || !(server._requestHandlers instanceof Map)) {
+    logCompatibilityWarning();
+    throw new Error(
+      "MCPCat SDK compatibility error: Server._requestHandlers is not accessible. This requires MCP SDK v1.11 or higher."
+    );
+  }
+  if (typeof server._requestHandlers.get !== "function") {
+    logCompatibilityWarning();
+    throw new Error(
+      "MCPCat SDK compatibility error: Server._requestHandlers must be a Map with a get method. This requires MCP SDK v1.11 or higher."
+    );
+  }
+  if (typeof server.getClientVersion !== "function") {
+    logCompatibilityWarning();
+    throw new Error(
+      "MCPCat SDK compatibility error: Server.getClientVersion must be a function. This requires MCP SDK v1.11 or higher."
+    );
+  }
+  if (!server._serverInfo || typeof server._serverInfo !== "object" || !server._serverInfo.name) {
+    logCompatibilityWarning();
+    throw new Error(
+      "MCPCat SDK compatibility error: Server._serverInfo is not accessible or missing name. This requires MCP SDK v1.11 or higher."
+    );
+  }
+}
+function getMCPCompatibleErrorMessage(error2) {
+  if (error2 instanceof Error) {
+    try {
+      return JSON.stringify(error2, Object.getOwnPropertyNames(error2));
+    } catch {
+      return "Unknown error";
+    }
+  } else if (typeof error2 === "string") {
+    return error2;
+  } else if (typeof error2 === "object" && error2 !== null) {
+    return JSON.stringify(error2);
+  }
+  return "Unknown error";
+}
+var maxLength = (array2, from, to) => Math.ceil(array2.length * Math.log2(from) / Math.log2(to));
+function baseConvertIntArray(array2, { from, to, fixedLength = null }) {
+  const length = fixedLength === null ? maxLength(array2, from, to) : fixedLength;
+  const result = new Array(length);
+  let offset = length;
+  let input = array2;
+  while (input.length > 0) {
+    if (offset === 0) {
+      throw new RangeError(
+        `Fixed length of ${fixedLength} is too small, expected at least ${maxLength(array2, from, to)}`
+      );
+    }
+    const quotients = [];
+    let remainder = 0;
+    for (const digit of input) {
+      const acc = digit + remainder * from;
+      const q = Math.floor(acc / to);
+      remainder = acc % to;
+      if (quotients.length > 0 || q > 0) {
+        quotients.push(q);
+      }
+    }
+    result[--offset] = remainder;
+    input = quotients;
+  }
+  if (fixedLength === null) {
+    return offset > 0 ? result.slice(offset) : result;
+  }
+  while (offset > 0) {
+    result[--offset] = 0;
+  }
+  return result;
+}
+var base_convert_int_array_default = baseConvertIntArray;
+var CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function encode(buffer, fixedLength) {
+  return base_convert_int_array_default(buffer, { from: 256, to: 62, fixedLength }).map((value) => CHARS[value]).join("");
+}
+function decode(string3, fixedLength) {
+  const input = Array.from(string3, (char) => {
+    const charCode = char.charCodeAt(0);
+    if (charCode < 58) return charCode - 48;
+    if (charCode < 91) return charCode - 55;
+    return charCode - 61;
+  });
+  return Buffer.from(
+    base_convert_int_array_default(input, { from: 62, to: 256, fixedLength })
+  );
+}
+var customInspectSymbol = inspect.custom;
+var asyncRandomBytes = promisify(randomBytes);
+var EPOCH_IN_MS = 14e11;
+var MAX_TIME_IN_MS = 1e3 * (2 ** 32 - 1) + EPOCH_IN_MS;
+var TIMESTAMP_BYTE_LENGTH = 4;
+var PAYLOAD_BYTE_LENGTH = 16;
+var BYTE_LENGTH = TIMESTAMP_BYTE_LENGTH + PAYLOAD_BYTE_LENGTH;
+var STRING_ENCODED_LENGTH = 27;
+var TIME_IN_MS_ASSERTION = `Valid KSUID timestamps must be in milliseconds since ${(/* @__PURE__ */ new Date(0)).toISOString()},
+  no earlier than ${new Date(EPOCH_IN_MS).toISOString()} and no later than ${new Date(MAX_TIME_IN_MS).toISOString()}
+`.trim().replace(/(\n|\s)+/g, " ").replace(/\.000Z/g, "Z");
+var VALID_ENCODING_ASSERTION = `Valid encoded KSUIDs are ${STRING_ENCODED_LENGTH} characters`;
+var VALID_BUFFER_ASSERTION = `Valid KSUID buffers are ${BYTE_LENGTH} bytes`;
+var VALID_PAYLOAD_ASSERTION = `Valid KSUID payloads are ${PAYLOAD_BYTE_LENGTH} bytes`;
+function fromParts(timeInMs, payload) {
+  const timestamp = Math.floor((timeInMs - EPOCH_IN_MS) / 1e3);
+  const timestampBuffer = Buffer.allocUnsafe(TIMESTAMP_BYTE_LENGTH);
+  timestampBuffer.writeUInt32BE(timestamp, 0);
+  return Buffer.concat([timestampBuffer, payload], BYTE_LENGTH);
+}
+var bufferLookup = /* @__PURE__ */ new WeakMap();
+var KSUID = class _KSUID {
+  constructor(buffer) {
+    if (!_KSUID.isValid(buffer)) {
+      throw new TypeError(VALID_BUFFER_ASSERTION);
+    }
+    bufferLookup.set(this, buffer);
+    Object.defineProperty(this, "buffer", {
+      enumerable: true,
+      get() {
+        return Buffer.from(buffer);
+      }
+    });
+  }
+  get raw() {
+    return Buffer.from(bufferLookup.get(this).slice(0));
+  }
+  get date() {
+    return new Date(1e3 * this.timestamp + EPOCH_IN_MS);
+  }
+  get timestamp() {
+    return bufferLookup.get(this).readUInt32BE(0);
+  }
+  get payload() {
+    const payload = bufferLookup.get(this).slice(TIMESTAMP_BYTE_LENGTH, BYTE_LENGTH);
+    return Buffer.from(payload);
+  }
+  get string() {
+    const encoded = encode(
+      bufferLookup.get(this),
+      STRING_ENCODED_LENGTH
+    );
+    return encoded.padStart(STRING_ENCODED_LENGTH, "0");
+  }
+  compare(other) {
+    if (!bufferLookup.has(other)) {
+      return 0;
+    }
+    return bufferLookup.get(this).compare(bufferLookup.get(other), 0, BYTE_LENGTH);
+  }
+  equals(other) {
+    return this === other || bufferLookup.has(other) && this.compare(other) === 0;
+  }
+  toString() {
+    return `${this[Symbol.toStringTag]} { ${this.string} }`;
+  }
+  toJSON() {
+    return this.string;
+  }
+  [customInspectSymbol]() {
+    return this.toString();
+  }
+  static async random(time3 = Date.now()) {
+    const payload = await asyncRandomBytes(PAYLOAD_BYTE_LENGTH);
+    return new _KSUID(fromParts(Number(time3), payload));
+  }
+  static randomSync(time3 = Date.now()) {
+    const payload = randomBytes(PAYLOAD_BYTE_LENGTH);
+    return new _KSUID(fromParts(Number(time3), payload));
+  }
+  static fromParts(timeInMs, payload) {
+    if (!Number.isInteger(timeInMs) || timeInMs < EPOCH_IN_MS || timeInMs > MAX_TIME_IN_MS) {
+      throw new TypeError(TIME_IN_MS_ASSERTION);
+    }
+    if (!Buffer.isBuffer(payload) || payload.byteLength !== PAYLOAD_BYTE_LENGTH) {
+      throw new TypeError(VALID_PAYLOAD_ASSERTION);
+    }
+    return new _KSUID(fromParts(timeInMs, payload));
+  }
+  static isValid(buffer) {
+    return Buffer.isBuffer(buffer) && buffer.byteLength === BYTE_LENGTH;
+  }
+  static parse(string3) {
+    if (string3.length !== STRING_ENCODED_LENGTH) {
+      throw new TypeError(VALID_ENCODING_ASSERTION);
+    }
+    const decoded = decode(string3, BYTE_LENGTH);
+    if (decoded.byteLength === BYTE_LENGTH) {
+      return new _KSUID(decoded);
+    }
+    const buffer = Buffer.allocUnsafe(BYTE_LENGTH);
+    const padEnd = BYTE_LENGTH - decoded.byteLength;
+    buffer.fill(0, 0, padEnd);
+    decoded.copy(buffer, padEnd);
+    return new _KSUID(buffer);
+  }
+};
+Object.defineProperty(KSUID.prototype, Symbol.toStringTag, { value: "KSUID" });
+Object.defineProperty(KSUID, "MAX_STRING_ENCODED", {
+  value: "aWgEPTl1tmebfsQzFP4bxwgy80V"
+});
+Object.defineProperty(KSUID, "MIN_STRING_ENCODED", {
+  value: "000000000000000000000000000"
+});
+KSUID.withPrefix = function(prefix) {
+  return {
+    random: async (time3 = Date.now()) => {
+      const ksuid2 = await KSUID.random(time3);
+      return `${prefix}_${ksuid2.string}`;
+    },
+    randomSync: (time3 = Date.now()) => {
+      const ksuid2 = KSUID.randomSync(time3);
+      return `${prefix}_${ksuid2.string}`;
+    },
+    fromParts: (timeInMs, payload) => {
+      const ksuid2 = KSUID.fromParts(timeInMs, payload);
+      return `${prefix}_${ksuid2.string}`;
+    }
+  };
+};
+var ksuid_default = KSUID;
+var package_default = {
+  name: "mcpcat",
+  version: "0.1.16",
+  description: "Analytics tool for MCP (Model Context Protocol) servers - tracks tool usage patterns and provides insights",
+  type: "module",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.cjs"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest",
+    "test:compatibility": "vitest run src/tests/mcp-version-compatibility.test.ts",
+    "test:esm-consume": "vitest run src/tests/esm-consumer.test.ts",
+    lint: "eslint src/",
+    typecheck: "tsc --noEmit",
+    prepare: "husky",
+    prepublishOnly: "pnpm run build && pnpm run test && pnpm run lint && pnpm run typecheck"
+  },
+  keywords: [
+    "ai",
+    "authentication",
+    "mcp",
+    "observability",
+    "ai-agents",
+    "ai-platform",
+    "ai-agent",
+    "mcps",
+    "aiagents",
+    "ai-agent-tools",
+    "mcp-servers",
+    "mcp-server",
+    "mcp-tools",
+    "agent-runtime",
+    "mcp-framework",
+    "mcp-analytics"
+  ],
+  author: "MCPcat",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/MCPCat/mcpcat-typescript-sdk.git"
+  },
+  bugs: {
+    url: "https://github.com/MCPCat/mcpcat-typescript-sdk/issues"
+  },
+  homepage: "https://github.com/MCPCat/mcpcat-typescript-sdk#readme",
+  packageManager: "pnpm@10.11.0",
+  devDependencies: {
+    "@changesets/cli": "^2.29.8",
+    "@modelcontextprotocol/sdk": "~1.24.2",
+    "@types/node": "^22.15.21",
+    "@types/uuid": "^11.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "@vitest/coverage-v8": "^4.0.14",
+    "@vitest/ui": "^4.0.14",
+    eslint: "^9.39.1",
+    husky: "^9.1.7",
+    "lint-staged": "^16.1.0",
+    prettier: "^3.5.3",
+    tsup: "^8.5.0",
+    typescript: "^5.8.3",
+    uuid: "^13.0.0",
+    vitest: "^4.0.14",
+    zod: "^3.25 || ^4.0"
+  },
+  peerDependencies: {
+    "@modelcontextprotocol/sdk": ">=1.11"
+  },
+  dependencies: {
+    "mcpcat-api": "0.1.9"
+  },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  pnpm: {
+    overrides: {
+      "js-yaml": ">=4.1.1",
+      tmp: ">=0.2.4",
+      vite: ">=6.4.1",
+      "body-parser": ">=2.2.1",
+      "brace-expansion": "2.0.2"
+    },
+    overridesComments: {
+      "js-yaml": "Fixes GHSA-mh29-5h37-fv8m (prototype pollution in merge) - via @changesets/cli",
+      tmp: "Fixes GHSA-52f5-9888-hmc6 (symlink attack) - via @changesets/cli",
+      vite: "Fixes GHSA-93m4-6634-74q7 and other vite security issues - via vitest",
+      "body-parser": "Fixes GHSA-wqch-xfxh-vrr4 (DoS via url encoding) - via @modelcontextprotocol/sdk",
+      "brace-expansion": "Fixes GHSA-v6h2-p8h4-qcjw (ReDoS vulnerability) - via eslint"
+    }
+  }
+};
+var INACTIVITY_TIMEOUT_IN_MINUTES = 30;
+var 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."`;
+var MCPCAT_SOURCE = "mcpcat";
+function newSessionId() {
+  return ksuid_default.withPrefix("ses").randomSync();
+}
+function deriveSessionIdFromMCPSession(mcpSessionId, projectId) {
+  const input = projectId ? `${mcpSessionId}:${projectId}` : mcpSessionId;
+  const hash = createHash2("sha256").update(input).digest();
+  const EPOCH_2024 = (/* @__PURE__ */ new Date("2024-01-01T00:00:00Z")).getTime();
+  const timestampOffset = hash.readUInt32BE(0) % (365 * 24 * 60 * 60 * 1e3);
+  const timestamp = EPOCH_2024 + timestampOffset;
+  const payload = hash.subarray(4, 20);
+  return ksuid_default.withPrefix("ses").fromParts(timestamp, payload);
+}
+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.projectId || void 0
+    );
+    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;
+  }
+  const now = Date.now();
+  const timeoutMs = INACTIVITY_TIMEOUT_IN_MINUTES * 60 * 1e3;
+  if (now - data.lastActivity.getTime() > timeoutMs) {
+    data.sessionId = newSessionId();
+    data.sessionSource = "mcpcat";
+    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,
+    // grab from django
+    sdkLanguage: "TypeScript",
+    // hardcoded for now
+    mcpcatVersion: package_default.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;
+}
+var PROTECTED_FIELDS = /* @__PURE__ */ new Set([
+  "sessionId",
+  "id",
+  "projectId",
+  "server",
+  "identifyActorGivenId",
+  "identifyActorName",
+  "identifyData",
+  "resourceName",
+  "eventType",
+  "actorId",
+  "tags",
+  "properties"
+]);
+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;
+      }
+      const fieldPath = path ? `${path}.${key}` : key;
+      const isFieldProtected = isProtected || path === "" && PROTECTED_FIELDS.has(key);
+      redactedObj[key] = await redactStringsInObject(
+        value,
+        redactFn,
+        fieldPath,
+        isFieldProtected
+      );
+    }
+    return redactedObj;
+  }
+  return obj;
+}
+async function redactEvent(event, redactFn) {
+  return redactStringsInObject(event, redactFn, "", false);
+}
+var BASE64_PATTERN = /^[A-Za-z0-9+/\n\r]+=*$/;
+var SIZE_GATE = 10240;
+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;
+}
+function sanitizeResponse(response) {
+  if (response == null || typeof response !== "object") {
+    return response;
+  }
+  const result = { ...response };
+  if (Array.isArray(result.content)) {
+    result.content = result.content.map(sanitizeContentBlock);
+  }
+  if (result.structuredContent != null && typeof result.structuredContent === "object") {
+    result.structuredContent = sanitizeParameters(result.structuredContent);
+  }
+  return result;
+}
+function sanitizeContentBlock(block) {
+  if (block == null || typeof block !== "object") {
+    return block;
+  }
+  switch (block.type) {
+    case "text":
+      return block;
+    case "image":
+      return {
+        type: "text",
+        text: "[image content redacted - not supported by MCPcat]"
+      };
+    case "audio":
+      return {
+        type: "text",
+        text: "[audio content redacted - not supported by MCPcat]"
+      };
+    case "resource":
+      return sanitizeResourceBlock(block);
+    case "resource_link":
+      return block;
+    default:
+      return {
+        type: "text",
+        text: `[unsupported content type "${block.type}" redacted - not supported by MCPcat]`
+      };
+  }
+}
+function sanitizeResourceBlock(block) {
+  if (block.resource && block.resource.blob !== void 0) {
+    return {
+      type: "text",
+      text: "[binary resource content redacted - not supported by MCPcat]"
+    };
+  }
+  return block;
+}
+function sanitizeParameters(obj) {
+  if (obj == null) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    if (obj.length >= SIZE_GATE && BASE64_PATTERN.test(obj)) {
+      return "[binary data redacted - not supported by MCPcat]";
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(sanitizeParameters);
+  }
+  if (obj instanceof Date) {
+    return obj;
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = sanitizeParameters(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var MAX_DEPTH = 10;
+var MAX_BREADTH = 100;
+var MAX_STRING_LENGTH = 32768;
+var MAX_EVENT_BYTES = 102400;
+var MAX_USER_INTENT_LENGTH = 2048;
+var MAX_ERROR_MESSAGE_LENGTH = 2048;
+var MAX_RESOURCE_NAME_LENGTH = 256;
+var MAX_METADATA_LENGTH = 256;
+var MAX_STACK_FRAMES = 50;
+var MAX_CONTENT_TEXT_LENGTH = 32768;
+var TRUNCATION_SUFFIX = "...";
+function normalize(input, depth = MAX_DEPTH, maxBreadth = MAX_BREADTH, maxStringLength = MAX_STRING_LENGTH) {
+  const memo = /* @__PURE__ */ new WeakSet();
+  return visit(input, depth, maxBreadth, maxStringLength, memo);
+}
+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") {
+    const name = value.name || "<anonymous>";
+    return `[Function: ${name}]`;
+  }
+  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, maxLength2) {
+  if (str == null) return str;
+  if (str.length <= maxLength2) return str;
+  return str.slice(0, maxLength2) + TRUNCATION_SUFFIX;
+}
+function truncateStackFrames(frames) {
+  if (!frames || frames.length <= MAX_STACK_FRAMES) return frames;
+  const half = Math.floor(MAX_STACK_FRAMES / 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?.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;
+}
+var textEncoder = new TextEncoder();
+function jsonByteSize(value) {
+  return textEncoder.encode(JSON.stringify(value)).length;
+}
+function truncateLargestFields(obj, maxBytes) {
+  let 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 * 0.5));
+      if (reduction < 10) continue;
+      const newLength = length - reduction;
+      setNestedValue(
+        result,
+        path,
+        getNestedValue(result, path).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)) {
+    obj.forEach(
+      (item, i) => 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) current = current[key];
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) current = current[path[i]];
+  current[path[path.length - 1]] = value;
+}
+function truncateToSize(event) {
+  if (jsonByteSize(event) <= MAX_EVENT_BYTES) return event;
+  for (let depth = MAX_DEPTH - 1; 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) <= MAX_EVENT_BYTES) 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);
+}
+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") {
+    result.error = { ...result.error };
+    result.error.message = truncateString(
+      result.error.message,
+      MAX_ERROR_MESSAGE_LENGTH
+    );
+    if (result.error.frames !== void 0) {
+      result.error.frames = truncateStackFrames(result.error.frames);
+    }
+  }
+  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);
+}
+var EventQueue = class {
+  constructor() {
+    this.queue = [];
+    this.processing = false;
+    this.maxRetries = 3;
+    this.maxQueueSize = 1e4;
+    this.concurrency = 5;
+    this.activeRequests = 0;
+    const config2 = new Configuration({ basePath: "https://api.mcpcat.io" });
+    this.apiClient = new EventsApi(config2);
+  }
+  configure(apiBaseUrl) {
+    const config2 = new Configuration({ basePath: apiBaseUrl });
+    this.apiClient = new EventsApi(config2);
+  }
+  setTelemetryManager(telemetryManager) {
+    this.telemetryManager = telemetryManager;
+  }
+  add(event) {
+    if (this.queue.length >= this.maxQueueSize) {
+      writeToLog("Event queue full, dropping oldest event");
+      this.queue.shift();
+    }
+    this.queue.push(event);
+    this.process();
+  }
+  async process() {
+    if (this.processing) return;
+    this.processing = true;
+    while (this.queue.length > 0 && this.activeRequests < this.concurrency) {
+      const event = this.queue.shift();
+      if (!event) continue;
+      if (event.redactionFn) {
+        try {
+          const redactedEvent = await redactEvent(event, event.redactionFn);
+          event.redactionFn = void 0;
+          Object.assign(event, redactedEvent);
+        } catch (error2) {
+          writeToLog(`Failed to redact event: ${error2}`);
+          continue;
+        }
+      }
+      try {
+        Object.assign(event, sanitizeEvent(event));
+      } catch (error2) {
+        writeToLog(`Failed to sanitize event: ${error2}`);
+        continue;
+      }
+      try {
+        Object.assign(event, truncateEvent(event));
+      } catch (error2) {
+        writeToLog(`Failed to truncate event: ${error2}`);
+        continue;
+      }
+      event.id = event.id || await ksuid_default.withPrefix("evt").random();
+      this.activeRequests++;
+      this.sendEvent(event).finally(() => {
+        this.activeRequests--;
+        this.process();
+      });
+    }
+    this.processing = false;
+  }
+  toPublishEventRequest(event) {
+    return {
+      // Core fields
+      id: event.id,
+      projectId: event.projectId,
+      sessionId: event.sessionId,
+      timestamp: event.timestamp,
+      duration: event.duration,
+      // Event data
+      eventType: event.eventType,
+      resourceName: event.resourceName,
+      parameters: event.parameters,
+      response: event.response,
+      userIntent: event.userIntent,
+      isError: event.isError,
+      error: event.error,
+      // Actor fields
+      identifyActorGivenId: event.identifyActorGivenId,
+      identifyActorName: event.identifyActorName,
+      identifyData: event.identifyActorData,
+      // Session info
+      ipAddress: event.ipAddress,
+      sdkLanguage: event.sdkLanguage,
+      mcpcatVersion: event.mcpcatVersion,
+      serverName: event.serverName,
+      serverVersion: event.serverVersion,
+      clientName: event.clientName,
+      clientVersion: event.clientVersion,
+      // Legacy fields
+      actorId: event.actorId || event.identifyActorGivenId,
+      eventId: event.eventId,
+      // Customer-defined metadata
+      tags: event.tags ?? void 0,
+      properties: event.properties ?? void 0
+    };
+  }
+  async sendEvent(event, retries = 0) {
+    if (this.telemetryManager) {
+      this.telemetryManager.export(event).catch((error2) => {
+        writeToLog(
+          `Telemetry export error: ${getMCPCompatibleErrorMessage(error2)}`
+        );
+      });
+    }
+    if (event.projectId) {
+      try {
+        const publishRequest = this.toPublishEventRequest(event);
+        await this.apiClient.publishEvent({
+          publishEventRequest: publishRequest
+        });
+        writeToLog(
+          `Successfully sent event ${event.id} | ${event.eventType} | ${event.projectId} | ${event.duration} ms | ${event.identifyActorGivenId || "anonymous"}`
+        );
+        writeToLog(`Event details: ${JSON.stringify(event)}`);
+      } catch (error2) {
+        writeToLog(
+          `Failed to send event ${event.id}, retrying... [Error: ${getMCPCompatibleErrorMessage(error2)}]`
+        );
+        if (retries < this.maxRetries) {
+          await this.delay(Math.pow(2, retries) * 1e3);
+          return this.sendEvent(event, retries + 1);
+        }
+        throw error2;
+      }
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // Get queue stats for monitoring
+  getStats() {
+    return {
+      queueLength: this.queue.length,
+      activeRequests: this.activeRequests,
+      isProcessing: this.processing
+    };
+  }
+  // Graceful shutdown - wait for active requests
+  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`
+      );
+    }
+  }
+};
+var 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 setTelemetryManager(telemetryManager) {
+  eventQueue.setTelemetryManager(telemetryManager);
+}
+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 duration3 = eventInput.duration || (eventInput.timestamp ? (/* @__PURE__ */ new Date()).getTime() - eventInput.timestamp.getTime() : void 0);
+  const fullEvent = {
+    // Core fields (id will be generated later in the queue)
+    id: eventInput.id || "",
+    sessionId: eventInput.sessionId || data.sessionId,
+    projectId: data.projectId,
+    // Event metadata
+    eventType: eventInput.eventType || "",
+    timestamp: eventInput.timestamp || /* @__PURE__ */ new Date(),
+    duration: duration3,
+    // Session context from sessionInfo
+    ipAddress: sessionInfo.ipAddress,
+    sdkLanguage: sessionInfo.sdkLanguage,
+    mcpcatVersion: sessionInfo.mcpcatVersion,
+    serverName: sessionInfo.serverName,
+    serverVersion: sessionInfo.serverVersion,
+    clientName: sessionInfo.clientName,
+    clientVersion: sessionInfo.clientVersion,
+    // Actor information from sessionInfo
+    identifyActorGivenId: sessionInfo.identifyActorGivenId,
+    identifyActorName: sessionInfo.identifyActorName,
+    identifyActorData: sessionInfo.identifyActorData,
+    // Event-specific data from input
+    resourceName: eventInput.resourceName,
+    parameters: eventInput.parameters,
+    response: eventInput.response,
+    userIntent: eventInput.userIntent,
+    isError: eventInput.isError,
+    error: eventInput.error,
+    // Preserve redaction function
+    redactionFn: eventInput.redactionFn,
+    // Customer-defined metadata
+    tags: eventInput.tags,
+    properties: eventInput.properties
+  };
+  eventQueue.add(fullEvent);
+}
+var TAG_KEY_REGEX = /^[a-zA-Z0-9$_.:\- ]+$/;
+var MAX_TAG_KEY_LENGTH = 32;
+var MAX_TAG_VALUE_LENGTH = 200;
+var MAX_TAG_ENTRIES = 50;
+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)}" \u2014 key contains invalid characters or is empty`
+      );
+      continue;
+    }
+    if (key.length > MAX_TAG_KEY_LENGTH) {
+      writeToLog(
+        `Dropping invalid tag: "${key}" \u2014 key exceeds max length of ${MAX_TAG_KEY_LENGTH}`
+      );
+      continue;
+    }
+    if (typeof value !== "string") {
+      writeToLog(
+        `Dropping invalid tag: "${key}" \u2014 non-string value (got ${typeof value})`
+      );
+      continue;
+    }
+    if (value.length > MAX_TAG_VALUE_LENGTH) {
+      writeToLog(
+        `Dropping invalid tag: "${key}" \u2014 value exceeds max length of ${MAX_TAG_VALUE_LENGTH}`
+      );
+      continue;
+    }
+    if (value.includes("\n")) {
+      writeToLog(
+        `Dropping invalid tag: "${key}" \u2014 value contains newline character`
+      );
+      continue;
+    }
+    valid.push([key, value]);
+  }
+  if (valid.length === 0) {
+    return null;
+  }
+  if (valid.length > MAX_TAG_ENTRIES) {
+    const dropped = valid.length - MAX_TAG_ENTRIES;
+    writeToLog(
+      `Dropping ${dropped} tag(s) \u2014 exceeds maximum of ${MAX_TAG_ENTRIES} entries per event`
+    );
+    valid.length = MAX_TAG_ENTRIES;
+  }
+  return Object.fromEntries(valid);
+}
+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;
+    }
+    return void 0;
+  }
+  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;
+  }
+};
+var _globalIdentityCache = new IdentityCache(1e3);
+var _serverTracking = /* @__PURE__ */ new WeakMap();
+function getServerTrackingData(server) {
+  return _serverTracking.get(server);
+}
+function setServerTrackingData(server, data) {
+  _serverTracking.set(server, data);
+}
+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;
+}
+function mergeIdentities(previous, next) {
+  if (!previous) {
+    return next;
+  }
+  return {
+    userId: next.userId,
+    userName: next.userName,
+    userData: {
+      ...previous.userData || {},
+      ...next.userData || {}
+    }
+  };
+}
+async function handleIdentify(server, data, request, extra) {
+  if (!data.options.identify) {
+    return;
+  }
+  const sessionId = data.sessionId;
+  let identifyEvent = {
+    sessionId,
+    resourceName: request.params?.name || "Unknown",
+    eventType: PublishEventRequestEventTypeEnum.mcpcatIdentify,
+    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 (error2) {
+    writeToLog(
+      `Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error2}`
+    );
+  }
+}
+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;
+  }
+}
+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 addContextParameterToTool(tool, customContextDescription) {
+  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 = customContextDescription || DEFAULT_CONTEXT_PARAMETER_DESCRIPTION;
+  modifiedTool.inputSchema = JSON.parse(
+    JSON.stringify(modifiedTool.inputSchema)
+  );
+  if (!modifiedTool.inputSchema.properties) {
+    modifiedTool.inputSchema.properties = {};
+  }
+  if (modifiedTool.inputSchema.additionalProperties === false) {
+    delete modifiedTool.inputSchema.additionalProperties;
+  }
+  modifiedTool.inputSchema.properties.context = {
+    type: "string",
+    description: contextDescription
+  };
+  if (Array.isArray(modifiedTool.inputSchema.required)) {
+    if (!modifiedTool.inputSchema.required.includes("context")) {
+      modifiedTool.inputSchema.required.push("context");
+    }
+  } else {
+    modifiedTool.inputSchema.required = ["context"];
+  }
+  return modifiedTool;
+}
+function addContextParameterToTools(tools, customContextDescription) {
+  return tools.map((tool) => {
+    if (tool.name === "get_more_tools") {
+      return tool;
+    }
+    return addContextParameterToTool(tool, customContextDescription);
+  });
+}
+var 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 setupMCPCatTools(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 MCPCat .track()."
+    );
+    return;
+  }
+  try {
+    server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+      let tools = [];
+      const data = getServerTrackingData(server);
+      let event = {
+        sessionId: getServerSessionId(server, extra),
+        parameters: {
+          request,
+          extra
+        },
+        eventType: PublishEventRequestEventTypeEnum.mcpToolsList,
+        timestamp: /* @__PURE__ */ new Date(),
+        redactionFn: data?.options.redactSensitiveInformation
+      };
+      try {
+        const originalResponse = await originalListToolsHandler(
+          request,
+          extra
+        );
+        tools = originalResponse.tools || [];
+      } catch (error2) {
+        writeToLog(
+          `Warning: Original list tools handler failed, this suggests an error MCPCat did not cause - ${error2}`
+        );
+        event.error = { message: getMCPCompatibleErrorMessage(error2) };
+        event.isError = true;
+        event.duration = event.timestamp && (/* @__PURE__ */ new Date()).getTime() - event.timestamp.getTime() || 0;
+        publishEvent(server, event);
+        throw error2;
+      }
+      if (!data) {
+        writeToLog(
+          "Warning: MCPCat 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 MCPCat.track()."
+        );
+        event.error = { message: "No tools were sent to MCP client." };
+        event.isError = true;
+        event.duration = event.timestamp && (/* @__PURE__ */ new Date()).getTime() - event.timestamp.getTime() || 0;
+        publishEvent(server, event);
+        return { tools };
+      }
+      if (data.options.enableToolCallContext) {
+        tools = addContextParameterToTools(
+          tools,
+          data.options.customContextDescription
+        );
+      }
+      if (data.options.enableReportMissing) {
+        const alreadyPresent = tools.some(
+          (t) => t?.name === GET_MORE_TOOLS_NAME
+        );
+        if (!alreadyPresent) {
+          tools.push(getReportMissingToolDescriptor());
+        }
+      }
+      event.response = { tools };
+      event.isError = false;
+      event.duration = event.timestamp && (/* @__PURE__ */ new Date()).getTime() - event.timestamp.getTime() || 0;
+      publishEvent(server, event);
+      return { tools };
+    });
+  } catch (error2) {
+    writeToLog(`Warning: Failed to override list tools handler - ${error2}`);
+  }
+}
+var fsModule2 = null;
+var fsInitAttempted = false;
+function getFsSync() {
+  if (!fsInitAttempted) {
+    fsInitAttempted = true;
+    try {
+      const require2 = createRequire2(import.meta.url);
+      fsModule2 = require2("fs");
+    } catch {
+      fsModule2 = null;
+    }
+  }
+  return fsModule2;
+}
+var MAX_EXCEPTION_CHAIN_DEPTH = 10;
+var MAX_STACK_FRAMES2 = 50;
+function captureException(error2, contextStack) {
+  if (isCallToolResult(error2)) {
+    return captureCallToolResultError(error2, contextStack);
+  }
+  if (!(error2 instanceof Error)) {
+    return {
+      message: stringifyNonError(error2),
+      type: void 0,
+      platform: "javascript"
+    };
+  }
+  const errorData = {
+    message: error2.message || "",
+    type: error2.name || error2.constructor?.name || void 0,
+    platform: "javascript"
+  };
+  if (error2.stack) {
+    errorData.stack = error2.stack;
+    errorData.frames = parseV8StackTrace(error2.stack);
+  }
+  const chainedErrors = unwrapErrorCauses(error2);
+  if (chainedErrors.length > 0) {
+    errorData.chained_errors = chainedErrors;
+  }
+  return errorData;
+}
+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_FRAMES2) {
+      break;
+    }
+  }
+  return frames;
+}
+function addContextToFrame(frame) {
+  if (!frame.in_app || !frame.abs_path || !frame.lineno) {
+    return frame;
+  }
+  const fs = getFsSync();
+  if (!fs) {
+    return frame;
+  }
+  try {
+    const source = fs.readFileSync(frame.abs_path, "utf8");
+    const lines = source.split("\n");
+    const lineIndex = frame.lineno - 1;
+    if (lineIndex >= 0 && lineIndex < lines.length) {
+      frame.context_line = lines[lineIndex];
+    }
+  } catch {
+  }
+  return frame;
+}
+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(/^(.+):(\d+):(\d+)$/);
+  if (match) {
+    const [, filename, lineStr, colStr] = match;
+    return {
+      filename: makeRelativePath(filename),
+      abs_path: filename,
+      lineno: parseInt(lineStr, 10),
+      colno: parseInt(colStr, 10)
+    };
+  }
+  return null;
+}
+function parseEvalOrigin(evalLocation) {
+  let evalChainPart = evalLocation;
+  const commaIndex = findCommaAfterBalancedParens(evalLocation);
+  if (commaIndex !== -1) {
+    evalChainPart = evalLocation.substring(0, commaIndex);
+  }
+  const match = evalChainPart.match(/^eval at (.+?) \((.+)\)$/);
+  if (!match) {
+    return null;
+  }
+  const innerLocation = match[2];
+  if (innerLocation.startsWith("eval at ")) {
+    return parseEvalOrigin(innerLocation);
+  }
+  const locationMatch = innerLocation.match(/^(.+):(\d+):(\d+)$/);
+  if (locationMatch) {
+    const [, filename, lineStr, colStr] = locationMatch;
+    return {
+      filename: makeRelativePath(filename),
+      abs_path: filename,
+      lineno: parseInt(lineStr, 10),
+      colno: parseInt(colStr, 10)
+    };
+  }
+  return null;
+}
+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;
+          } else if (str[j] !== " ") {
+            return -1;
+          }
+        }
+        return -1;
+      }
+    }
+  }
+  return -1;
+}
+function parseV8StackFrame(line) {
+  const withoutAt = line.substring(3);
+  const matchWithFunction = withoutAt.match(/^(.+?)\s+\((.+)\)$/);
+  if (matchWithFunction) {
+    const [, functionName, location] = matchWithFunction;
+    const parsedLocation2 = parseLocation(location);
+    if (parsedLocation2) {
+      return {
+        function: functionName.trim(),
+        filename: parsedLocation2.filename,
+        abs_path: parsedLocation2.abs_path,
+        lineno: parsedLocation2.lineno,
+        colno: parsedLocation2.colno,
+        in_app: isInApp(parsedLocation2.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
+  };
+}
+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;
+}
+function normalizeUrl(filename) {
+  if (filename.startsWith("file://")) {
+    let result = filename.substring(7);
+    if (!result.startsWith("/") && !result.match(/^[A-Za-z]:/)) {
+      result = "/" + result;
+    }
+    return result;
+  }
+  return filename;
+}
+function normalizeNodeInternals(filename) {
+  if (filename.startsWith("node:internal")) {
+    return "node:internal";
+  }
+  if (filename.startsWith("node:")) {
+    const parts = filename.split("/");
+    return parts[0];
+  }
+  return filename;
+}
+function stripSystemPrefixes(path) {
+  path = path.replace(/^\/Users\/[^/]+\//, "~/");
+  path = path.replace(/^\/home\/[^/]+\//, "~/");
+  path = path.replace(/^[A-Za-z]:[\\\/]Users[\\\/][^\\\/]+[\\\/]/, "~/");
+  return path;
+}
+function normalizeNodeModules(path) {
+  const unixIndex = path.lastIndexOf("/node_modules/");
+  const winIndex = path.lastIndexOf("\\node_modules\\");
+  if (unixIndex !== -1) {
+    return path.substring(unixIndex + 1);
+  }
+  if (winIndex !== -1) {
+    return path.substring(winIndex + 1).replace(/\\/g, "/");
+  }
+  return path;
+}
+function stripDeploymentPaths(path) {
+  const deploymentPrefixes = [
+    /^\/var\/www\/[^/]+\//,
+    // Apache/nginx: /var/www/myapp/
+    /^\/var\/task\//,
+    // AWS Lambda: /var/task/
+    /^\/usr\/src\/app\//,
+    // Docker: /usr/src/app/
+    /^\/app\//,
+    // Heroku, Docker, generic: /app/
+    /^\/opt\/[^/]+\//,
+    // Optional software: /opt/myapp/
+    /^\/srv\/[^/]+\//
+    // Service data: /srv/myapp/
+  ];
+  for (const prefix of deploymentPrefixes) {
+    path = path.replace(prefix, "");
+  }
+  return path;
+}
+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.substring(index + 1);
+    }
+  }
+  for (const marker of secondaryMarkers) {
+    const index = path.lastIndexOf(marker);
+    if (index !== -1) {
+      return path.substring(index + 1);
+    }
+  }
+  return path;
+}
+function makeRelativePath(filename) {
+  let result = filename;
+  result = normalizeUrl(result);
+  if (!result.startsWith("/") && !result.match(/^[A-Za-z]:\\/)) {
+    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.substring(cwd.length + 1);
+  }
+  if (result.startsWith("/") || result.match(/^[A-Za-z]:[/]/)) {
+    result = findProjectPath(result);
+  } else if (result.startsWith("~")) {
+    const withoutTilde = result.substring(2);
+    const projectPath = findProjectPath("/" + withoutTilde);
+    if (projectPath !== "/" + withoutTilde) {
+      result = projectPath;
+    }
+  }
+  if (result.startsWith("/")) {
+    result = result.substring(1);
+  }
+  return result;
+}
+function unwrapErrorCauses(error2) {
+  const chainedErrors = [];
+  const seenErrors = /* @__PURE__ */ new Set();
+  let currentError = error2.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;
+}
+function isCallToolResult(value) {
+  return value !== null && typeof value === "object" && "isError" in value && "content" in value && Array.isArray(value.content);
+}
+function captureCallToolResultError(result, _contextStack) {
+  const message = result.content?.filter((c) => c.type === "text").map((c) => c.text).join(" ").trim() || "Unknown error";
+  const errorData = {
+    message,
+    type: void 0,
+    // Can't determine actual type from CallToolResult
+    platform: "javascript"
+    // No stack or frames - SDK stripped the original error information
+  };
+  return errorData;
+}
+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);
+  }
+}
+function isToolResultError(result) {
+  return result && typeof result === "object" && result.isError === true;
+}
+var listToolsTracingSetup = /* @__PURE__ */ new WeakMap();
+function setupListToolsTracing(highLevelServer) {
+  const server = highLevelServer.server;
+  if (!server._capabilities?.tools) {
+    return;
+  }
+  if (listToolsTracingSetup.get(server)) {
+    return;
+  }
+  const handlers = server._requestHandlers;
+  const originalListToolsHandler = handlers.get("tools/list");
+  if (!originalListToolsHandler) {
+    return;
+  }
+  try {
+    server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+      let tools = [];
+      const data = getServerTrackingData(server);
+      let event = {
+        sessionId: getServerSessionId(server, extra),
+        parameters: {
+          request,
+          extra
+        },
+        eventType: PublishEventRequestEventTypeEnum.mcpToolsList,
+        timestamp: /* @__PURE__ */ new Date(),
+        redactionFn: data?.options.redactSensitiveInformation
+      };
+      if (data) {
+        const resolvedTags = await resolveEventTags(data, request, extra);
+        if (resolvedTags) event.tags = resolvedTags;
+        const resolvedProperties = await resolveEventProperties(
+          data,
+          request,
+          extra
+        );
+        if (resolvedProperties) event.properties = resolvedProperties;
+      }
+      try {
+        const originalResponse = await originalListToolsHandler(
+          request,
+          extra
+        );
+        tools = originalResponse.tools || [];
+        if (data?.options.enableToolCallContext) {
+          tools = addContextParameterToTools(
+            tools,
+            data.options.customContextDescription
+          );
+        }
+        if (data?.options.enableReportMissing) {
+          const alreadyPresent = tools.some(
+            (t) => t?.name === GET_MORE_TOOLS_NAME
+          );
+          if (!alreadyPresent) tools.push(getReportMissingToolDescriptor());
+        }
+      } catch (error2) {
+        writeToLog(
+          `Warning: Original list tools handler failed, this suggests an error MCPCat did not cause - ${error2}`
+        );
+        event.error = { message: getMCPCompatibleErrorMessage(error2) };
+        event.isError = true;
+        event.duration = event.timestamp && (/* @__PURE__ */ new Date()).getTime() - event.timestamp.getTime() || 0;
+        publishEvent(server, event);
+        throw error2;
+      }
+      if (!data) {
+        writeToLog(
+          "Warning: MCPCat 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 MCPCat.track()."
+        );
+        event.error = { message: "No tools were sent to MCP client." };
+        event.isError = true;
+        event.duration = event.timestamp && (/* @__PURE__ */ new Date()).getTime() - event.timestamp.getTime() || 0;
+        publishEvent(server, event);
+        return { tools };
+      }
+      event.response = { tools };
+      event.isError = false;
+      event.duration = event.timestamp && (/* @__PURE__ */ new Date()).getTime() - event.timestamp.getTime() || 0;
+      publishEvent(server, event);
+      return { tools };
+    });
+    listToolsTracingSetup.set(server, true);
+  } catch (error2) {
+    writeToLog(`Warning: Failed to override list tools handler - ${error2}`);
+  }
+}
+function setupInitializeTracing(highLevelServer) {
+  const server = highLevelServer.server;
+  const handlers = server._requestHandlers;
+  const originalInitializeHandler = handlers.get("initialize");
+  if (originalInitializeHandler) {
+    server.setRequestHandler(
+      InitializeRequestSchema,
+      async (request, extra) => {
+        const data = getServerTrackingData(server);
+        if (!data) {
+          writeToLog(
+            "Warning: MCPCat 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);
+        let event = {
+          sessionId,
+          resourceName: request.params?.name || "Unknown Tool Name",
+          eventType: PublishEventRequestEventTypeEnum.mcpInitialize,
+          parameters: {
+            request,
+            extra
+          },
+          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: MCPCat 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);
+          let event = {
+            sessionId,
+            resourceName: request.params?.name || "Unknown Tool Name",
+            eventType: PublishEventRequestEventTypeEnum.mcpInitialize,
+            parameters: {
+              request,
+              extra
+            },
+            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) => {
+      const data = getServerTrackingData(server);
+      if (!data) {
+        writeToLog(
+          "Warning: MCPCat 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 sessionId = getServerSessionId(server, extra);
+      let event = {
+        sessionId,
+        resourceName: request.params?.name || "Unknown Tool Name",
+        parameters: {
+          request,
+          extra
+        },
+        eventType: PublishEventRequestEventTypeEnum.mcpToolsCall,
+        timestamp: /* @__PURE__ */ new Date(),
+        redactionFn: data.options.redactSensitiveInformation
+      };
+      try {
+        await handleIdentify(server, 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;
+        if (data.options.enableToolCallContext && request.params?.name !== "get_more_tools") {
+          const hasContext = request.params?.arguments && typeof request.params.arguments === "object" && "context" in request.params.arguments;
+          if (hasContext) {
+            event.userIntent = request.params.arguments.context;
+          }
+        }
+        let result;
+        if (request.params?.name === "get_more_tools") {
+          result = await handleReportMissing(request.params.arguments.context);
+          event.userIntent = request.params.arguments.context;
+        } else if (originalCallToolHandler) {
+          result = await originalCallToolHandler(request, extra);
+        } else {
+          event.isError = true;
+          event.error = {
+            message: `Tool call handler not found for ${request.params?.name || "unknown"}`
+          };
+          event.duration = event.timestamp && (/* @__PURE__ */ new Date()).getTime() - event.timestamp.getTime() || void 0;
+          publishEvent(server, event);
+          throw new Error(`Unknown tool: ${request.params?.name || "unknown"}`);
+        }
+        if (isToolResultError(result)) {
+          event.isError = true;
+          event.error = captureException(result);
+        }
+        event.response = result;
+        publishEvent(server, event);
+        return result;
+      } catch (error2) {
+        event.isError = true;
+        event.error = captureException(error2);
+        publishEvent(server, event);
+        throw error2;
+      }
+    });
+  } catch (error2) {
+    writeToLog(`Warning: Failed to setup tool call tracing - ${error2}`);
+    throw error2;
+  }
+}
+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");
+}
+function getToolFunctionKey(tool) {
+  if ("handler" in tool && typeof tool.handler === "function") {
+    return "handler";
+  }
+  return "callback";
+}
+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";
+}
+function createWrappedTool(originalTool, wrappedFunction) {
+  const key = getToolFunctionKey(originalTool);
+  return {
+    ...originalTool,
+    [key]: wrappedFunction
+  };
+}
+function isZ4Schema2(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  return !!schema._zod;
+}
+function getObjectShape2(schema) {
+  if (!schema || typeof schema !== "object") return void 0;
+  let rawShape;
+  if (isZ4Schema2(schema)) {
+    const v4Schema = schema;
+    rawShape = v4Schema._zod?.def?.shape;
+  } else {
+    const v3Schema = schema;
+    rawShape = v3Schema.shape ?? v3Schema._def?.shape;
+  }
+  if (!rawShape) return void 0;
+  if (typeof rawShape === "function") {
+    try {
+      return rawShape();
+    } catch {
+      return void 0;
+    }
+  }
+  return rawShape;
+}
+function getLiteralValue2(schema) {
+  if (!schema || typeof schema !== "object") return void 0;
+  if (isZ4Schema2(schema)) {
+    const v4Schema = schema;
+    const def = v4Schema._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 v3Schema = schema;
+    const def = v3Schema._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;
+  return void 0;
+}
+var wrappedCallbacks = /* @__PURE__ */ new WeakMap();
+var MCPCAT_PROCESSED = /* @__PURE__ */ Symbol("__mcpcat_processed__");
+function isToolResultError2(result) {
+  return result && typeof result === "object" && result.isError === true;
+}
+function addTracingToToolRegistry(tools, server) {
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, tool]) => [
+      name,
+      addTracingToToolCallbackInternal(tool, name, server)
+    ])
+  );
+}
+function setupListenerToRegisteredTools(server) {
+  try {
+    const data = getServerTrackingData(server.server);
+    if (!data) {
+      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[MCPCAT_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);
+            }
+            value = addTracingToToolCallbackInternal(value, property, server);
+            setupListToolsTracing(server);
+            if (typeof value.update === "function") {
+              const originalUpdate = value.update;
+              value.update = function(...updateArgs) {
+                if (updateArgs[0]) {
+                  const updateObj = updateArgs[0];
+                  if (updateObj.callback && typeof updateObj.callback === "function") {
+                    const wrappedTool = addTracingToToolCallbackInternal(
+                      { callback: updateObj.callback },
+                      property,
+                      server
+                    );
+                    updateObj.callback = getToolFunction(wrappedTool);
+                  }
+                }
+                return originalUpdate.apply(this, updateArgs);
+              };
+            }
+          }
+          return Reflect.set(target, property, value);
+        } catch (error2) {
+          writeToLog(
+            `Warning: Error in proxy set handler for tool ${String(property)} - ${error2}`
+          );
+          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 (error2) {
+    writeToLog(
+      `Warning: Failed to setup listener for registered tools - ${error2}`
+    );
+  }
+}
+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[MCPCAT_PROCESSED]) {
+    writeToLog(`Tool ${toolName} already processed, skipping re-wrap`);
+    return tool;
+  }
+  const wrappedCallback = async function(...params) {
+    let args;
+    let extra;
+    if (params.length === 2) {
+      args = params[0];
+      extra = params[1];
+    } else {
+      args = void 0;
+      extra = params[0];
+    }
+    const removeContextFromArgs = (args2) => {
+      if (args2 && typeof args2 === "object" && "context" in args2) {
+        const { context: _context, ...argsWithoutContext } = args2;
+        return argsWithoutContext;
+      }
+      return args2;
+    };
+    const cleanedArgs = toolName === "get_more_tools" ? args : removeContextFromArgs(args);
+    try {
+      if (cleanedArgs === void 0) {
+        const handler = originalCallback;
+        return await handler(extra);
+      } else {
+        const handler = originalCallback;
+        return await handler(cleanedArgs, extra);
+      }
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        extra.__mcpcat_error = error2;
+      }
+      throw error2;
+    }
+  };
+  wrappedCallbacks.set(originalCallback, true);
+  wrappedCallbacks.set(wrappedCallback, true);
+  const wrappedTool = createWrappedTool(tool, wrappedCallback);
+  wrappedTool[MCPCAT_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 = function(requestSchema, handler) {
+    const shape = getObjectShape2(requestSchema);
+    const method = shape?.method ? getLiteralValue2(shape.method) : void 0;
+    if (method === "tools/call") {
+      const wrappedHandler = createToolsCallWrapper(handler, lowLevelServer);
+      return originalSetRequestHandler(requestSchema, wrappedHandler);
+    }
+    return originalSetRequestHandler(requestSchema, handler);
+  };
+}
+function createToolsCallWrapper(originalHandler, server) {
+  return async (request, extra) => {
+    const startTime = /* @__PURE__ */ new Date();
+    let shouldPublishEvent = false;
+    let event = null;
+    try {
+      const data = getServerTrackingData(server);
+      if (!data) {
+        writeToLog(
+          "Warning: MCPCat is unable to find server tracking data. Please ensure you have called track(server, options) before using tool calls."
+        );
+      } else {
+        shouldPublishEvent = true;
+        const sessionId = getServerSessionId(server, extra);
+        event = {
+          sessionId,
+          resourceName: request.params?.name || "Unknown Tool",
+          parameters: { request, extra },
+          eventType: PublishEventRequestEventTypeEnum.mcpToolsCall,
+          timestamp: startTime,
+          redactionFn: data.options.redactSensitiveInformation
+        };
+        await handleIdentify(server, data, request, extra);
+        event.sessionId = data.sessionId;
+        const resolvedTags = await resolveEventTags(data, request, extra);
+        if (resolvedTags) event.tags = resolvedTags;
+        const resolvedProperties = await resolveEventProperties(
+          data,
+          request,
+          extra
+        );
+        if (resolvedProperties) event.properties = resolvedProperties;
+        if (data.options.enableToolCallContext && request.params?.arguments?.context) {
+          event.userIntent = request.params.arguments.context;
+        }
+      }
+    } catch (error2) {
+      writeToLog(
+        `Warning: MCPCat tracing failed for tool ${request.params?.name}, falling back to original handler - ${error2}`
+      );
+    }
+    if (request?.params?.name === "get_more_tools") {
+      try {
+        const result = await handleReportMissing({
+          context: request?.params?.arguments?.context
+        });
+        if (event && shouldPublishEvent) {
+          event.userIntent = request?.params?.arguments?.context;
+          event.response = result;
+          event.duration = (/* @__PURE__ */ new Date()).getTime() - startTime.getTime();
+          publishEvent(server, event);
+        }
+        return result;
+      } catch (error2) {
+        if (event && shouldPublishEvent) {
+          event.isError = true;
+          event.error = captureException(error2);
+          event.duration = (/* @__PURE__ */ new Date()).getTime() - startTime.getTime();
+          publishEvent(server, event);
+        }
+        throw error2;
+      }
+    }
+    try {
+      const result = await originalHandler(request, extra);
+      if (event && shouldPublishEvent) {
+        if (isToolResultError2(result)) {
+          event.isError = true;
+          const capturedError = extra.__mcpcat_error;
+          if (capturedError) {
+            event.error = captureException(capturedError);
+            delete extra.__mcpcat_error;
+          } else {
+            event.error = captureException(result);
+          }
+        }
+        event.response = result;
+        event.duration = (/* @__PURE__ */ new Date()).getTime() - startTime.getTime();
+        publishEvent(server, event);
+      }
+      return result;
+    } catch (error2) {
+      if (event && shouldPublishEvent) {
+        event.isError = true;
+        event.error = captureException(error2);
+        event.duration = (/* @__PURE__ */ new Date()).getTime() - startTime.getTime();
+        publishEvent(server, event);
+      }
+      throw error2;
+    }
+  };
+}
+function setupTracking(server) {
+  try {
+    const _mcpcatData = getServerTrackingData(server.server);
+    setupToolsCallHandlerWrapping(server);
+    setupInitializeTracing(server);
+    server._registeredTools = addTracingToToolRegistry(
+      server._registeredTools,
+      server
+    );
+    setupListToolsTracing(server);
+    setupListenerToRegisteredTools(server);
+  } catch (error2) {
+    writeToLog(`Warning: Failed to setup tool call tracing - ${error2}`);
+  }
+}
+var TraceContext = class {
+  getTraceId(sessionId) {
+    if (!sessionId) {
+      return randomBytes2(16).toString("hex");
+    }
+    return createHash22("sha256").update(sessionId).digest("hex").substring(0, 32);
+  }
+  getSpanId(eventId) {
+    if (!eventId) {
+      return randomBytes2(8).toString("hex");
+    }
+    return createHash22("sha256").update(eventId).digest("hex").substring(0, 16);
+  }
+  getDatadogTraceId(sessionId) {
+    const hex = this.getTraceId(sessionId);
+    return BigInt("0x" + hex.substring(16, 32)).toString();
+  }
+  getDatadogSpanId(eventId) {
+    const hex = this.getSpanId(eventId);
+    return BigInt("0x" + hex).toString();
+  }
+};
+var traceContext = new TraceContext();
+var OTLPExporter = class {
+  constructor(config2) {
+    const url = config2.endpoint.replace(/\/+$/, "");
+    this.endpoint = url.endsWith("/v1/traces") ? url : `${url}/v1/traces`;
+    this.headers = {
+      "Content-Type": "application/json",
+      // Using JSON for now for easier debugging
+      ...config2.headers
+    };
+  }
+  async export(event) {
+    try {
+      const span = this.convertToOTLPSpan(event);
+      const otlpRequest = {
+        resourceSpans: [
+          {
+            resource: {
+              attributes: [
+                {
+                  key: "service.name",
+                  value: { stringValue: event.serverName || "mcp-server" }
+                },
+                {
+                  key: "service.version",
+                  value: { stringValue: event.serverVersion || "unknown" }
+                }
+              ]
+            },
+            scopeSpans: [
+              {
+                scope: {
+                  name: "mcpcat",
+                  version: event.mcpcatVersion || "unknown"
+                },
+                spans: [span]
+              }
+            ]
+          }
+        ]
+      };
+      const body = JSON.stringify(otlpRequest);
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: this.headers,
+        body
+      });
+      if (!response.ok) {
+        throw new Error(
+          `OTLP export failed: ${response.status} ${response.statusText}`
+        );
+      }
+      writeToLog(`Successfully exported event to OTLP: ${event.id}`);
+    } catch (error2) {
+      throw new Error(`OTLP export error: ${error2}`);
+    }
+  }
+  convertToOTLPSpan(event) {
+    const startTimeNanos = event.timestamp ? BigInt(event.timestamp.getTime()) * BigInt(1e6) : BigInt(Date.now()) * BigInt(1e6);
+    const endTimeNanos = event.duration ? startTimeNanos + BigInt(event.duration) * BigInt(1e6) : startTimeNanos;
+    return {
+      traceId: traceContext.getTraceId(event.sessionId),
+      spanId: traceContext.getSpanId(event.id),
+      name: event.eventType || "mcp.event",
+      kind: 2,
+      // SPAN_KIND_SERVER
+      startTimeUnixNano: startTimeNanos.toString(),
+      endTimeUnixNano: endTimeNanos.toString(),
+      attributes: [
+        {
+          key: "source",
+          value: { stringValue: MCPCAT_SOURCE }
+        },
+        {
+          key: "mcp.event_type",
+          value: { stringValue: event.eventType || "" }
+        },
+        {
+          key: "mcp.session_id",
+          value: { stringValue: event.sessionId || "" }
+        },
+        {
+          key: "mcp.project_id",
+          value: { stringValue: event.projectId || "" }
+        },
+        {
+          key: "mcp.resource_name",
+          value: { stringValue: event.resourceName || "" }
+        },
+        {
+          key: "mcp.user_intent",
+          value: { stringValue: event.userIntent || "" }
+        },
+        {
+          key: "mcp.actor_id",
+          value: { stringValue: event.identifyActorGivenId || "" }
+        },
+        {
+          key: "mcp.actor_name",
+          value: { stringValue: event.identifyActorName || "" }
+        },
+        {
+          key: "mcp.client_name",
+          value: { stringValue: event.clientName || "" }
+        },
+        {
+          key: "mcp.client_version",
+          value: { stringValue: event.clientVersion || "" }
+        },
+        // Add customer-defined tags as individual attributes
+        ...Object.entries(event.tags || {}).map(([key, value]) => ({
+          key: `mcpcat.tag.${key}`,
+          value: { stringValue: value }
+        })),
+        // Add customer-defined properties as JSON
+        ...event.properties ? [
+          {
+            key: "mcpcat.properties",
+            value: { stringValue: JSON.stringify(event.properties) }
+          }
+        ] : []
+      ].filter((attr) => attr.value.stringValue),
+      // Remove empty attributes
+      status: {
+        code: event.isError ? 2 : 1
+        // ERROR : OK
+      }
+    };
+  }
+};
+var DatadogExporter = class {
+  constructor(config2) {
+    this.config = config2;
+    const site = config2.site.replace(/^https?:\/\//, "").replace(/\/$/, "");
+    this.logsUrl = `https://http-intake.logs.${site}/api/v2/logs`;
+    this.metricsUrl = `https://api.${site}/api/v1/series`;
+  }
+  async export(event) {
+    writeToLog("DatadogExporter: Sending event immediately to Datadog");
+    const log = this.eventToLog(event);
+    const metrics = this.eventToMetrics(event);
+    writeToLog(`DatadogExporter: Metrics URL: ${this.metricsUrl}`);
+    writeToLog(
+      `DatadogExporter: Metrics payload: ${JSON.stringify({ series: metrics })}`
+    );
+    const logsPromise = fetch(this.logsUrl, {
+      method: "POST",
+      headers: {
+        "DD-API-KEY": this.config.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify([log])
+    }).then(async (response) => {
+      if (!response.ok) {
+        const errorBody = await response.text();
+        writeToLog(
+          `Datadog logs failed - Status: ${response.status}, Body: ${errorBody}`
+        );
+      } else {
+        writeToLog(`Datadog logs success - Status: ${response.status}`);
+      }
+      return response;
+    }).catch((err) => {
+      writeToLog(`Datadog logs network error: ${err}`);
+    });
+    const metricsPromise = fetch(this.metricsUrl, {
+      method: "POST",
+      headers: {
+        "DD-API-KEY": this.config.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ series: metrics })
+    }).then(async (response) => {
+      if (!response.ok) {
+        const errorBody = await response.text();
+        writeToLog(
+          `Datadog metrics failed - Status: ${response.status}, Body: ${errorBody}`
+        );
+      } else {
+        const responseBody = await response.text();
+        writeToLog(
+          `Datadog metrics success - Status: ${response.status}, Body: ${responseBody}`
+        );
+      }
+      return response;
+    }).catch((err) => {
+      writeToLog(`Datadog metrics network error: ${err}`);
+    });
+    await Promise.all([logsPromise, metricsPromise]);
+  }
+  eventToLog(event) {
+    const tags = [];
+    if (this.config.env) tags.push(`env:${this.config.env}`);
+    if (event.eventType)
+      tags.push(`event_type:${event.eventType.replace(/\//g, ".")}`);
+    if (event.resourceName) tags.push(`resource:${event.resourceName}`);
+    if (event.isError) tags.push("error:true");
+    tags.push(`source:${MCPCAT_SOURCE}`);
+    if (event.tags) {
+      for (const [key, value] of Object.entries(event.tags)) {
+        const sanitizedKey = key.toLowerCase().replace(/[\s:,]+/g, "_");
+        const sanitizedValue = value.replace(/,/g, "_");
+        tags.push(`mcpcat.${sanitizedKey}:${sanitizedValue}`);
+      }
+    }
+    const log = {
+      message: `${event.eventType || "unknown"} - ${event.resourceName || "unknown"}`,
+      service: this.config.service,
+      ddsource: MCPCAT_SOURCE,
+      ddtags: tags.join(","),
+      timestamp: event.timestamp ? event.timestamp.getTime() : Date.now(),
+      status: event.isError ? "error" : "info",
+      dd: {
+        trace_id: traceContext.getDatadogTraceId(event.sessionId),
+        span_id: traceContext.getDatadogSpanId(event.id)
+      },
+      mcp: {
+        session_id: event.sessionId,
+        event_id: event.id,
+        event_type: event.eventType,
+        resource: event.resourceName,
+        duration_ms: event.duration,
+        user_intent: event.userIntent,
+        actor_id: event.identifyActorGivenId,
+        actor_name: event.identifyActorName,
+        client_name: event.clientName,
+        client_version: event.clientVersion,
+        server_name: event.serverName,
+        server_version: event.serverVersion,
+        is_error: event.isError,
+        error: event.error,
+        tags: event.tags,
+        properties: event.properties
+      }
+    };
+    if (event.isError && event.error) {
+      log.error = {
+        message: typeof event.error === "string" ? event.error : JSON.stringify(event.error)
+      };
+    }
+    return log;
+  }
+  eventToMetrics(event) {
+    const metrics = [];
+    const timestamp = Math.floor(
+      (event.timestamp?.getTime() || Date.now()) / 1e3
+    );
+    const tags = [`service:${this.config.service}`];
+    if (this.config.env) tags.push(`env:${this.config.env}`);
+    if (event.eventType)
+      tags.push(`event_type:${event.eventType.replace(/\//g, ".")}`);
+    if (event.resourceName) tags.push(`resource:${event.resourceName}`);
+    metrics.push({
+      metric: "mcp.events.count",
+      type: "count",
+      points: [[timestamp, 1]],
+      tags
+    });
+    if (event.duration) {
+      metrics.push({
+        metric: "mcp.event.duration",
+        type: "gauge",
+        points: [[timestamp, event.duration]],
+        tags
+      });
+    }
+    if (event.isError) {
+      metrics.push({
+        metric: "mcp.errors.count",
+        type: "count",
+        points: [[timestamp, 1]],
+        tags
+      });
+    }
+    return metrics;
+  }
+};
+var SentryExporter = class {
+  constructor(config2) {
+    this.config = config2;
+    this.parsedDSN = this.parseDSN(config2.dsn);
+    this.endpoint = `${this.parsedDSN.protocol}://${this.parsedDSN.host}${this.parsedDSN.port ? `:${this.parsedDSN.port}` : ""}${this.parsedDSN.path}/api/${this.parsedDSN.projectId}/envelope/`;
+    this.authHeader = `Sentry sentry_version=7, sentry_client=mcpcat/1.0.0, sentry_key=${this.parsedDSN.publicKey}`;
+    writeToLog(`SentryExporter: Initialized with endpoint ${this.endpoint}`);
+  }
+  parseDSN(dsn) {
+    const regex = /^(https?):\/\/([a-f0-9]+)@([\w.-]+)(:\d+)?(\/.*)?\/(\d+)$/;
+    const match = dsn.match(regex);
+    if (!match) {
+      throw new Error(`Invalid Sentry DSN: ${dsn}`);
+    }
+    return {
+      protocol: match[1],
+      publicKey: match[2],
+      host: match[3],
+      port: match[4]?.substring(1),
+      // Remove leading ':'
+      path: match[5] || "",
+      projectId: match[6]
+    };
+  }
+  async export(event) {
+    try {
+      const log = this.eventToLog(event);
+      const logEnvelope = this.createLogEnvelope(log);
+      writeToLog(`SentryExporter: Sending log for event ${event.id} to Sentry`);
+      const logResponse = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "X-Sentry-Auth": this.authHeader,
+          "Content-Type": "application/x-sentry-envelope"
+        },
+        body: logEnvelope
+      });
+      if (!logResponse.ok) {
+        const errorBody = await logResponse.text();
+        writeToLog(
+          `Sentry log export failed - Status: ${logResponse.status}, Body: ${errorBody}`
+        );
+      } else {
+        writeToLog(`Sentry log export success - Event: ${event.id}`);
+      }
+      if (this.config.enableTracing) {
+        const transaction = this.eventToTransaction(event);
+        const transactionEnvelope = this.createTransactionEnvelope(transaction);
+        writeToLog(
+          `SentryExporter: Sending transaction ${transaction.event_id} to Sentry`
+        );
+        const transactionResponse = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "X-Sentry-Auth": this.authHeader,
+            "Content-Type": "application/x-sentry-envelope"
+          },
+          body: transactionEnvelope
+        });
+        if (!transactionResponse.ok) {
+          const errorBody = await transactionResponse.text();
+          writeToLog(
+            `Sentry transaction export failed - Status: ${transactionResponse.status}, Body: ${errorBody}`
+          );
+        } else {
+          writeToLog(`Sentry transaction export success - Event: ${event.id}`);
+        }
+      }
+      if (event.isError) {
+        const errorEvent = this.config.enableTracing ? this.eventToErrorEvent(event, this.eventToTransaction(event)) : this.eventToErrorEvent(event);
+        const errorEnvelope = this.createErrorEnvelope(errorEvent);
+        writeToLog(
+          `SentryExporter: Sending error event ${errorEvent.event_id} to Sentry for Issue creation`
+        );
+        const errorResponse = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "X-Sentry-Auth": this.authHeader,
+            "Content-Type": "application/x-sentry-envelope"
+          },
+          body: errorEnvelope
+        });
+        if (!errorResponse.ok) {
+          const errorBody = await errorResponse.text();
+          writeToLog(
+            `Sentry error export failed - Status: ${errorResponse.status}, Body: ${errorBody}`
+          );
+        } else {
+          writeToLog(`Sentry error export success - Event: ${event.id}`);
+        }
+      }
+    } catch (error2) {
+      writeToLog(`Sentry export error: ${error2}`);
+    }
+  }
+  eventToLog(event) {
+    const timestamp = event.timestamp ? new Date(event.timestamp).getTime() / 1e3 : Date.now() / 1e3;
+    const traceId = traceContext.getTraceId(event.sessionId);
+    const eventId = traceContext.getSpanId(event.id) + traceContext.getSpanId(event.id);
+    const message = event.resourceName ? `MCP ${event.eventType || "event"}: ${event.resourceName}` : `MCP ${event.eventType || "event"}`;
+    return {
+      timestamp,
+      trace_id: traceId,
+      event_id: eventId,
+      level: event.isError ? "error" : "info",
+      body: message,
+      attributes: this.buildLogAttributes(event)
+    };
+  }
+  buildLogAttributes(event) {
+    const attributes = {};
+    if (event.eventType) {
+      attributes.eventType = { value: event.eventType, type: "string" };
+    }
+    if (event.resourceName) {
+      attributes.resourceName = { value: event.resourceName, type: "string" };
+    }
+    if (event.serverName) {
+      attributes.serverName = { value: event.serverName, type: "string" };
+    }
+    if (event.clientName) {
+      attributes.clientName = { value: event.clientName, type: "string" };
+    }
+    if (event.sessionId) {
+      attributes.sessionId = { value: event.sessionId, type: "string" };
+    }
+    if (event.projectId) {
+      attributes.projectId = { value: event.projectId, type: "string" };
+    }
+    if (event.duration !== void 0) {
+      attributes.duration_ms = { value: event.duration, type: "double" };
+    }
+    if (event.identifyActorGivenId) {
+      attributes.actorId = {
+        value: event.identifyActorGivenId,
+        type: "string"
+      };
+    }
+    if (event.identifyActorName) {
+      attributes.actorName = { value: event.identifyActorName, type: "string" };
+    }
+    if (event.userIntent) {
+      attributes.userIntent = { value: event.userIntent, type: "string" };
+    }
+    if (event.serverVersion) {
+      attributes.serverVersion = { value: event.serverVersion, type: "string" };
+    }
+    if (event.clientVersion) {
+      attributes.clientVersion = { value: event.clientVersion, type: "string" };
+    }
+    if (event.isError !== void 0) {
+      attributes.isError = { value: event.isError, type: "boolean" };
+    }
+    return attributes;
+  }
+  createLogEnvelope(log) {
+    const envelopeHeader = {
+      event_id: log.event_id,
+      sent_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const itemHeader = {
+      type: "log",
+      item_count: 1,
+      // MANDATORY - must match number of logs
+      content_type: "application/vnd.sentry.items.log+json"
+      // MANDATORY - exact string
+    };
+    const payload = {
+      items: [log]
+      // Changed from 'logs' to 'items'
+    };
+    return [
+      JSON.stringify(envelopeHeader),
+      JSON.stringify(itemHeader),
+      JSON.stringify(payload)
+    ].join("\n") + "\n";
+  }
+  eventToTransaction(event) {
+    const endTimestamp = event.timestamp ? new Date(event.timestamp).getTime() / 1e3 : Date.now() / 1e3;
+    const startTimestamp = event.duration ? endTimestamp - event.duration / 1e3 : endTimestamp;
+    const traceId = traceContext.getTraceId(event.sessionId);
+    const spanId = traceContext.getSpanId(event.id);
+    const transactionName = event.resourceName ? `${event.eventType || "mcp"} - ${event.resourceName}` : event.eventType || "mcp.event";
+    const transaction = {
+      type: "transaction",
+      event_id: traceContext.getSpanId(event.id) + traceContext.getSpanId(),
+      timestamp: endTimestamp,
+      start_timestamp: startTimestamp,
+      transaction: transactionName,
+      contexts: this.buildContexts(event, {
+        trace_id: traceId,
+        span_id: spanId,
+        op: event.eventType || "mcp.event",
+        status: event.isError ? "internal_error" : "ok"
+      }),
+      tags: this.buildTags(event),
+      extra: this.buildExtra(event)
+    };
+    return transaction;
+  }
+  buildTags(event) {
+    const tags = {
+      source: MCPCAT_SOURCE
+    };
+    if (this.config.environment) tags.environment = this.config.environment;
+    if (this.config.release) tags.release = this.config.release;
+    if (event.eventType) tags.event_type = event.eventType;
+    if (event.resourceName) tags.resource = event.resourceName;
+    if (event.serverName) tags.server_name = event.serverName;
+    if (event.clientName) tags.client_name = event.clientName;
+    if (event.identifyActorGivenId) tags.actor_id = event.identifyActorGivenId;
+    if (event.tags) {
+      for (const [key, value] of Object.entries(event.tags)) {
+        tags[`mcpcat.${key}`] = value;
+      }
+    }
+    return tags;
+  }
+  buildExtra(event) {
+    const extra = {};
+    if (event.sessionId) extra.session_id = event.sessionId;
+    if (event.projectId) extra.project_id = event.projectId;
+    if (event.userIntent) extra.user_intent = event.userIntent;
+    if (event.identifyActorName) extra.actor_name = event.identifyActorName;
+    if (event.serverVersion) extra.server_version = event.serverVersion;
+    if (event.clientVersion) extra.client_version = event.clientVersion;
+    if (event.duration !== void 0) extra.duration_ms = event.duration;
+    if (event.error) extra.error = event.error;
+    return extra;
+  }
+  buildContexts(event, traceCtx) {
+    const contexts = {
+      trace: traceCtx
+    };
+    if (event.properties) {
+      contexts.mcpcat = event.properties;
+    }
+    return contexts;
+  }
+  eventToErrorEvent(event, transaction) {
+    let errorMessage = "Unknown error";
+    let errorType = "ToolCallError";
+    if (event.error) {
+      if (typeof event.error === "string") {
+        errorMessage = event.error;
+      } else if (typeof event.error === "object" && event.error !== null) {
+        if ("message" in event.error) {
+          errorMessage = String(event.error.message);
+        } else {
+          errorMessage = JSON.stringify(event.error);
+        }
+        if ("type" in event.error) {
+          errorType = String(event.error.type);
+        }
+      }
+    }
+    const traceId = transaction ? transaction.contexts.trace.trace_id : traceContext.getTraceId(event.sessionId);
+    const spanId = traceContext.getSpanId(event.id);
+    const timestamp = transaction ? transaction.timestamp : event.timestamp ? new Date(event.timestamp).getTime() / 1e3 : Date.now() / 1e3;
+    const errorEvent = {
+      type: "event",
+      event_id: traceContext.getSpanId(event.id) + traceContext.getSpanId(),
+      timestamp,
+      level: "error",
+      exception: {
+        values: [
+          {
+            type: errorType,
+            value: errorMessage,
+            mechanism: {
+              type: "mcp_tool_call",
+              handled: false
+            }
+          }
+        ]
+      },
+      contexts: {
+        ...this.buildContexts(event, {
+          trace_id: traceId,
+          span_id: spanId,
+          parent_span_id: transaction?.contexts.trace.span_id,
+          op: transaction?.contexts.trace.op || event.eventType || "mcp.event"
+        }),
+        mcp: {
+          resource_name: event.resourceName,
+          session_id: event.sessionId,
+          event_type: event.eventType,
+          user_intent: event.userIntent
+        }
+      },
+      tags: this.buildTags(event),
+      extra: this.buildExtra(event),
+      transaction: transaction?.transaction || (event.resourceName ? `${event.eventType || "mcp"} - ${event.resourceName}` : event.eventType || "mcp.event")
+      // Generate transaction name if not available
+    };
+    return errorEvent;
+  }
+  createTransactionEnvelope(transaction) {
+    const envelopeHeader = {
+      event_id: transaction.event_id,
+      sent_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const itemHeader = {
+      type: "transaction"
+    };
+    return [
+      JSON.stringify(envelopeHeader),
+      JSON.stringify(itemHeader),
+      JSON.stringify(transaction)
+    ].join("\n");
+  }
+  createErrorEnvelope(errorEvent) {
+    const envelopeHeader = {
+      event_id: errorEvent.event_id,
+      sent_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const itemHeader = {
+      type: "event",
+      content_type: "application/json"
+    };
+    return [
+      JSON.stringify(envelopeHeader),
+      JSON.stringify(itemHeader),
+      JSON.stringify(errorEvent)
+    ].join("\n");
+  }
+};
+function toUUIDv7(prefixedId) {
+  const ksuidStr = prefixedId.replace(/^[a-z]+_/, "");
+  let timestampMs;
+  try {
+    const ksuid2 = ksuid_default.parse(ksuidStr);
+    timestampMs = ksuid2.date.getTime();
+  } catch {
+    timestampMs = Date.now();
+  }
+  const hash = createHash3("sha256").update(prefixedId).digest();
+  const buf = Buffer.alloc(16);
+  buf.writeUIntBE(timestampMs, 0, 6);
+  buf[6] = 112 | hash[0] & 15;
+  buf[7] = hash[1];
+  buf[8] = 128 | hash[2] & 63;
+  buf[9] = hash[3];
+  buf[10] = hash[4];
+  buf[11] = hash[5];
+  buf[12] = hash[6];
+  buf[13] = hash[7];
+  buf[14] = hash[8];
+  buf[15] = hash[9];
+  const hex = buf.toString("hex");
+  return [
+    hex.substring(0, 8),
+    hex.substring(8, 12),
+    hex.substring(12, 16),
+    hex.substring(16, 20),
+    hex.substring(20, 32)
+  ].join("-");
+}
+function getDistinctId(event) {
+  return event.identifyActorGivenId || event.sessionId || "anonymous";
+}
+function getTimestamp(event) {
+  return event.timestamp ? event.timestamp.toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+}
+var PostHogExporter = class {
+  constructor(config2) {
+    this.config = config2;
+    const host = (config2.host || "https://us.i.posthog.com").replace(/\/$/, "");
+    this.batchUrl = `${host}/batch`;
+    this.apiKey = config2.apiKey;
+    writeToLog(`PostHogExporter: Initialized with endpoint ${this.batchUrl}`);
+  }
+  async export(event) {
+    try {
+      const batch = [];
+      batch.push(this.buildCaptureEvent(event));
+      if (event.isError && event.error) {
+        batch.push(this.buildExceptionEvent(event));
+      }
+      if (this.config.enableAITracing && event.eventType === PublishEventRequestEventTypeEnum.mcpToolsCall) {
+        batch.push(this.buildAISpanEvent(event));
+      }
+      writeToLog(
+        `PostHogExporter: Sending ${batch.length} event(s) for ${event.id}`
+      );
+      const response = await fetch(this.batchUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          api_key: this.apiKey,
+          batch
+        })
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        writeToLog(
+          `PostHog export failed - Status: ${response.status}, Body: ${errorBody}`
+        );
+      } else {
+        writeToLog(`PostHog export success - Event: ${event.id}`);
+      }
+    } catch (error2) {
+      writeToLog(`PostHog export error: ${error2}`);
+    }
+  }
+  buildCaptureEvent(event) {
+    const distinctId = getDistinctId(event);
+    const eventName = this.mapEventType(event.eventType);
+    const timestamp = getTimestamp(event);
+    const properties = {
+      $session_id: toUUIDv7(event.sessionId),
+      source: MCPCAT_SOURCE
+    };
+    if (event.resourceName) {
+      properties.resource_name = event.resourceName;
+      if (event.eventType === PublishEventRequestEventTypeEnum.mcpToolsCall) {
+        properties.tool_name = event.resourceName;
+      }
+    }
+    if (event.duration !== void 0) {
+      properties.duration_ms = event.duration;
+    }
+    if (event.serverName) properties.server_name = event.serverName;
+    if (event.serverVersion) properties.server_version = event.serverVersion;
+    if (event.clientName) properties.client_name = event.clientName;
+    if (event.clientVersion) properties.client_version = event.clientVersion;
+    if (event.projectId) properties.project_id = event.projectId;
+    if (event.userIntent) properties.user_intent = event.userIntent;
+    if (event.isError !== void 0) properties.is_error = event.isError;
+    if (event.parameters !== void 0) {
+      properties.parameters = event.parameters;
+    }
+    if (event.response !== void 0) {
+      properties.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;
+    }
+    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: eventName,
+      distinct_id: distinctId,
+      properties,
+      timestamp,
+      type: "capture"
+    };
+  }
+  buildExceptionEvent(event) {
+    const distinctId = getDistinctId(event);
+    const timestamp = getTimestamp(event);
+    const properties = {
+      $exception_source: "backend",
+      $session_id: toUUIDv7(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.resource_name = event.resourceName;
+      if (event.eventType === PublishEventRequestEventTypeEnum.mcpToolsCall) {
+        properties.tool_name = event.resourceName;
+      }
+    }
+    if (event.serverName) properties.server_name = event.serverName;
+    if (event.serverVersion) properties.server_version = event.serverVersion;
+    if (event.clientName) properties.client_name = event.clientName;
+    if (event.clientVersion) properties.client_version = event.clientVersion;
+    return {
+      event: "$exception",
+      distinct_id: distinctId,
+      properties,
+      timestamp,
+      type: "capture"
+    };
+  }
+  buildAISpanEvent(event) {
+    const distinctId = getDistinctId(event);
+    const timestamp = getTimestamp(event);
+    const properties = {
+      $ai_session_id: `mcpcat_${event.sessionId}`,
+      $ai_trace_id: toUUIDv7(event.sessionId),
+      $ai_span_id: toUUIDv7(event.id),
+      $ai_span_name: event.resourceName || "unknown_tool",
+      $ai_is_error: event.isError || false,
+      $session_id: toUUIDv7(event.sessionId),
+      source: MCPCAT_SOURCE
+    };
+    if (event.duration !== void 0) {
+      properties.$ai_latency = event.duration / 1e3;
+    }
+    if (event.isError && event.error) {
+      properties.$ai_error = event.error;
+    }
+    if (event.parameters !== void 0) {
+      properties.$ai_input_state = event.parameters;
+    }
+    if (event.response !== void 0) {
+      properties.$ai_output_state = event.response;
+    }
+    if (event.serverName) properties.server_name = event.serverName;
+    if (event.clientName) properties.client_name = event.clientName;
+    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"
+    };
+  }
+  mapEventType(eventType) {
+    const mapping = {
+      [PublishEventRequestEventTypeEnum.mcpToolsCall]: "mcp_tool_call",
+      [PublishEventRequestEventTypeEnum.mcpToolsList]: "mcp_tools_list",
+      [PublishEventRequestEventTypeEnum.mcpInitialize]: "mcp_initialize",
+      [PublishEventRequestEventTypeEnum.mcpResourcesRead]: "mcp_resource_read",
+      [PublishEventRequestEventTypeEnum.mcpResourcesList]: "mcp_resources_list",
+      [PublishEventRequestEventTypeEnum.mcpPromptsGet]: "mcp_prompt_get",
+      [PublishEventRequestEventTypeEnum.mcpPromptsList]: "mcp_prompts_list"
+    };
+    return mapping[eventType] || `mcp_${eventType.replace(/^mcp:/, "").replace(/\//g, "_")}`;
+  }
+};
+var TelemetryManager = class {
+  constructor(exporterConfigs) {
+    this.exporters = /* @__PURE__ */ new Map();
+    if (!exporterConfigs) return;
+    for (const [name, config2] of Object.entries(exporterConfigs)) {
+      try {
+        const exporter = this.createExporter(name, config2);
+        if (exporter) {
+          this.exporters.set(name, exporter);
+          writeToLog(`Initialized telemetry exporter: ${name}`);
+        }
+      } catch (error2) {
+        writeToLog(`Failed to initialize exporter ${name}: ${error2}`);
+      }
+    }
+  }
+  createExporter(name, config2) {
+    switch (config2.type) {
+      case "otlp":
+        return new OTLPExporter(config2);
+      case "datadog":
+        return new DatadogExporter(config2);
+      case "sentry":
+        return new SentryExporter(config2);
+      case "posthog":
+        return new PostHogExporter(config2);
+      default:
+        writeToLog(`Unknown exporter type: ${config2.type}`);
+        return null;
+    }
+  }
+  async export(event) {
+    if (this.exporters.size === 0) return;
+    for (const [name, exporter] of this.exporters) {
+      exporter.export(event).catch((error2) => {
+        const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+        writeToLog(`Telemetry export failed for ${name}: ${errorMessage}`);
+      });
+    }
+  }
+  getExporterCount() {
+    return this.exporters.size;
+  }
+};
+function track(server, projectId, options = {}) {
+  try {
+    const validatedServer = isCompatibleServerType(server);
+    const apiBaseUrl = options.apiBaseUrl || process.env.MCPCAT_API_URL;
+    if (apiBaseUrl) {
+      eventQueue.configure(apiBaseUrl);
+    }
+    const lowLevelServer = isHighLevelServer(validatedServer) ? validatedServer.server : validatedServer;
+    const existingData = getServerTrackingData(lowLevelServer);
+    if (existingData) {
+      writeToLog(
+        "[SESSION DEBUG] track() - Server already being tracked, skipping initialization"
+      );
+      return validatedServer;
+    }
+    if (options.exporters) {
+      const telemetryManager = new TelemetryManager(options.exporters);
+      setTelemetryManager(telemetryManager);
+      writeToLog(
+        `Initialized telemetry with ${Object.keys(options.exporters).length} exporters`
+      );
+    }
+    if (!projectId && !options.exporters) {
+      writeToLog(
+        "Warning: No projectId provided and no exporters configured. Events will not be sent anywhere."
+      );
+    }
+    const sessionInfo = getSessionInfo(lowLevelServer, void 0);
+    const mcpcatData = {
+      projectId: projectId || "",
+      // Use empty string for null projectId
+      sessionId: newSessionId(),
+      lastActivity: /* @__PURE__ */ new Date(),
+      identifiedSessions: /* @__PURE__ */ new Map(),
+      sessionInfo,
+      options: {
+        enableReportMissing: options.enableReportMissing ?? true,
+        enableTracing: options.enableTracing ?? true,
+        enableToolCallContext: options.enableToolCallContext ?? true,
+        customContextDescription: options.customContextDescription,
+        identify: options.identify,
+        redactSensitiveInformation: options.redactSensitiveInformation,
+        eventTags: options.eventTags,
+        eventProperties: options.eventProperties
+      },
+      sessionSource: "mcpcat"
+      // Initially MCPCat-generated, will change to "mcp" if MCP sessionId is provided in requests
+    };
+    setServerTrackingData(lowLevelServer, mcpcatData);
+    if (isHighLevelServer(validatedServer)) {
+      const highLevelServer = validatedServer;
+      setupTracking(highLevelServer);
+    } else {
+      if (mcpcatData.options.enableReportMissing) {
+        try {
+          setupMCPCatTools(lowLevelServer);
+        } catch (error2) {
+          writeToLog(`Warning: Failed to setup report missing tool - ${error2}`);
+        }
+      }
+      if (mcpcatData.options.enableTracing) {
+        try {
+          setupToolCallTracing(lowLevelServer);
+        } catch (error2) {
+          writeToLog(`Warning: Failed to setup tool call tracing - ${error2}`);
+        }
+      }
+    }
+    return validatedServer;
+  } catch (error2) {
+    writeToLog(`Warning: Failed to track server - ${error2}`);
+    return server;
+  }
+}
+
+// ../../src/mcp/mcpcat.ts
+var EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+var SSN_RE = /\b\d{3}[-\s]\d{2}[-\s]\d{4}\b/g;
+var CC_CANDIDATE_RE = /\b(?:\d[ -]?){13,19}\b/g;
+var PHONE_INTL_RE = /\+\d[\d\s().-]{5,16}\d/g;
+var PHONE_NANP_RE = /\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}\b/g;
+function isLuhnValid(digits) {
+  if (digits.length < 13 || digits.length > 19) return false;
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = digits.charCodeAt(i) - 48;
+    if (n < 0 || n > 9) return false;
+    if (double) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function redactPII(text) {
+  return text.replace(EMAIL_RE, "[redacted-email]").replace(SSN_RE, "[redacted-ssn]").replace(
+    CC_CANDIDATE_RE,
+    (m) => isLuhnValid(m.replace(/\D/g, "")) ? "[redacted-cc]" : m
+  ).replace(PHONE_INTL_RE, "[redacted-phone]").replace(PHONE_NANP_RE, "[redacted-phone]");
+}
+function trackWithMcpcat(server) {
+  const projectId = process.env.MCPCAT_PROJECT_ID?.trim();
+  if (!projectId) return;
+  track(server, projectId, {
+    enableToolCallContext: false,
+    enableReportMissing: false,
+    // RedactFunction is typed async; redactPII is sync, so wrap it.
+    redactSensitiveInformation: (text) => Promise.resolve(redactPII(text))
+  });
+}
+
 // ../../src/mcp/server.ts
 var READ_ONLY_TOOL_ANNOTATIONS = {
   readOnlyHint: true,
@@ -24500,6 +28321,7 @@ function createMcpServer() {
   server.server.registerCapabilities({
     extensions: { "io.modelcontextprotocol/ui": {} }
   });
+  trackWithMcpcat(server);
   return server;
 }