@savvly/mcp-server 1.0.19 → 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.19";
+var SERVER_VERSION = "1.0.21";
 
 // ../../src/mcp/ui/payout-chart.ts
 var PAYOUT_UI_URI = "ui://savvly/payout-chart.html";
@@ -23818,7 +23818,7 @@ function disclosureBlock() {
   };
 }
 var DISCLOSURE_REQUIRED_TERSE = "DISCLOSURE REQUIRED: display `disclosure.text` verbatim and link `disclosure.url` to the user alongside any figures from this response. Required by SEC Marketing Rule and FINRA Rule 2210 \u2014 do not paraphrase or omit.";
-var VISUALIZATION_RECOMMENDED_TERSE = "VISUALIZATION: this tool renders its chart inline as an interactive widget (MCP Apps \u2014 see `_meta.ui`); your host displays it automatically from the tool result. That widget IS the visualization \u2014 do NOT draw, generate, or render your own chart, graph, or table of these numbers (no duplicate). Summarize the key figures in prose and show the `disclosure` text and link.";
+var VISUALIZATION_RECOMMENDED_TERSE = "VISUALIZATION: this tool emits an interactive chart widget (MCP Apps \u2014 see `_meta.ui`). MCP-Apps-capable hosts render it inline and editable; other clients render only your text and show no chart. Do NOT draw, generate, or render your own chart, graph, or table of these numbers \u2014 there is no fallback chart for you to build, so never produce a duplicate. Do NOT claim or imply a chart is visible (avoid 'the chart above shows\u2026'); you cannot tell whether the host rendered the widget. Summarize the key figures in prose and show the `disclosure` text and link, and reference the chart only conditionally (e.g. 'if your client shows the interactive chart, its fields are editable to re-run the projection').";
 var INPUTS_OPTIONAL_NO_PROMPT_TERSE = "INPUTS: every parameter is OPTIONAL and defaults to a sensible value. Call this tool IMMEDIATELY \u2014 pass only the values the user explicitly stated and omit the rest. Do NOT ask the user for starting values, assumptions, or missing parameters before calling; the rendered widget has editable fields so they adjust age, amounts, and other assumptions inline after it appears.";
 var SAVVLY_VS_MARKET_ALONE_PAYOUT_METHODOLOGY = "Payout methodology \u2014 Savvly vs market alone: the payout values are calculated by comparing two investors of the same age committing the same principal. Investor 1 invests in the market with Savvly's Longevity Benefit Fund; Investor 2 invests in the market alone (no longevity overlay). To make the comparison apples-to-apples, at each milestone age (80, 85, 90, 95) Investor 2 withdraws from their market alone portfolio the same dollar amount Investor 1 receives as a payout from Savvly. The `payout_market_alone_*` and `total_market_alone_*` figures are therefore what Investor 2 can actually withdraw to match Savvly's payouts before running out \u2014 they fall to 0 once the market alone portfolio is depleted. The `savvly_upside_*` (and `total_savvly_upside_*`) fields quantify how much more total money Investor 1 receives in payouts from Savvly than Investor 2 is able to withdraw over time to match those payouts.";
 function summarizePayouts(envelope, depositType, deposited) {
@@ -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,
@@ -24497,6 +28318,10 @@ function createMcpServer() {
   server.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
     prompts: []
   }));
+  server.server.registerCapabilities({
+    extensions: { "io.modelcontextprotocol/ui": {} }
+  });
+  trackWithMcpcat(server);
   return server;
 }