@modelcontextprotocol/server-customer-segmentation 1.3.1 → 1.4.0

package/dist/index.js

@@ -20839,7 +20839,7 @@ var require_utils2 = __commonJS((exports, module) => {
   var hexTable = function() {
     var array2 = [];
     for (var i = 0;i < 256; ++i) {
-      array2.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
+      array2[array2.length] = "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase();
     }
     return array2;
   }();
@@ -20851,7 +20851,7 @@ var require_utils2 = __commonJS((exports, module) => {
         var compacted = [];
         for (var j = 0;j < obj.length; ++j) {
           if (typeof obj[j] !== "undefined") {
-            compacted.push(obj[j]);
+            compacted[compacted.length] = obj[j];
           }
         }
         item.obj[item.prop] = compacted;
@@ -20873,12 +20873,18 @@ var require_utils2 = __commonJS((exports, module) => {
     }
     if (typeof source !== "object" && typeof source !== "function") {
       if (isArray(target)) {
-        target.push(source);
+        var nextIndex = target.length;
+        if (options && typeof options.arrayLimit === "number" && nextIndex > options.arrayLimit) {
+          return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
+        }
+        target[nextIndex] = source;
       } else if (target && typeof target === "object") {
         if (isOverflow(target)) {
           var newIndex = getMaxIndex(target) + 1;
           target[newIndex] = source;
           setMaxIndex(target, newIndex);
+        } else if (options && options.strictMerge) {
+          return [target, source];
         } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
           target[source] = true;
         }
@@ -20897,7 +20903,11 @@ var require_utils2 = __commonJS((exports, module) => {
         }
         return markOverflow(result, getMaxIndex(source) + 1);
       }
-      return [target].concat(source);
+      var combined = [target].concat(source);
+      if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) {
+        return markOverflow(arrayToObject(combined, options), combined.length - 1);
+      }
+      return combined;
     }
     var mergeTarget = target;
     if (isArray(target) && !isArray(source)) {
@@ -20910,7 +20920,7 @@ var require_utils2 = __commonJS((exports, module) => {
           if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
             target[i] = merge3(targetItem, item, options);
           } else {
-            target.push(item);
+            target[target.length] = item;
           }
         } else {
           target[i] = item;
@@ -20925,6 +20935,15 @@ var require_utils2 = __commonJS((exports, module) => {
       } else {
         acc[key] = value;
       }
+      if (isOverflow(source) && !isOverflow(acc)) {
+        markOverflow(acc, getMaxIndex(source));
+      }
+      if (isOverflow(acc)) {
+        var keyNum = parseInt(key, 10);
+        if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
+          setMaxIndex(acc, keyNum);
+        }
+      }
       return acc;
     }, mergeTarget);
   };
@@ -21002,8 +21021,8 @@ var require_utils2 = __commonJS((exports, module) => {
         var key = keys[j];
         var val = obj[key];
         if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
-          queue.push({ obj, prop: key });
-          refs.push(val);
+          queue[queue.length] = { obj, prop: key };
+          refs[refs.length] = val;
         }
       }
     }
@@ -21036,7 +21055,7 @@ var require_utils2 = __commonJS((exports, module) => {
     if (isArray(val)) {
       var mapped = [];
       for (var i = 0;i < val.length; i += 1) {
-        mapped.push(fn(val[i]));
+        mapped[mapped.length] = fn(val[i]);
       }
       return mapped;
     }
@@ -21052,6 +21071,7 @@ var require_utils2 = __commonJS((exports, module) => {
     isBuffer,
     isOverflow,
     isRegExp,
+    markOverflow,
     maybeMap,
     merge: merge2
   };
@@ -21323,6 +21343,7 @@ var require_parse = __commonJS((exports, module) => {
     parseArrays: true,
     plainObjects: false,
     strictDepth: false,
+    strictMerge: true,
     strictNullHandling: false,
     throwOnLimitExceeded: false
   };
@@ -21393,9 +21414,15 @@ var require_parse = __commonJS((exports, module) => {
       if (part.indexOf("[]=") > -1) {
         val = isArray(val) ? [val] : val;
       }
+      if (options.comma && isArray(val) && val.length > options.arrayLimit) {
+        if (options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        }
+        val = utils.combine([], val, options.arrayLimit, options.plainObjects);
+      }
       if (key !== null) {
         var existing = has.call(obj, key);
-        if (existing && options.duplicates === "combine") {
+        if (existing && (options.duplicates === "combine" || part.indexOf("[]=") > -1)) {
           obj[key] = utils.combine(obj[key], val, options.arrayLimit, options.plainObjects);
         } else if (!existing || options.duplicates === "last") {
           obj[key] = val;
@@ -21425,11 +21452,17 @@ var require_parse = __commonJS((exports, module) => {
         var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
         var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
         var index = parseInt(decodedRoot, 10);
+        var isValidArrayIndex = !isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;
         if (!options.parseArrays && decodedRoot === "") {
           obj = { 0: leaf };
-        } else if (!isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && (options.parseArrays && index <= options.arrayLimit)) {
+        } else if (isValidArrayIndex && index < options.arrayLimit) {
           obj = [];
           obj[index] = leaf;
+        } else if (isValidArrayIndex && options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        } else if (isValidArrayIndex) {
+          obj[index] = leaf;
+          utils.markOverflow(obj, index);
         } else if (decodedRoot !== "__proto__") {
           obj[decodedRoot] = leaf;
         }
@@ -21459,7 +21492,7 @@ var require_parse = __commonJS((exports, module) => {
           return;
         }
       }
-      keys.push(parent);
+      keys[keys.length] = parent;
     }
     var i = 0;
     while ((segment = child.exec(key)) !== null && i < options.depth) {
@@ -21470,13 +21503,13 @@ var require_parse = __commonJS((exports, module) => {
           return;
         }
       }
-      keys.push(segment[1]);
+      keys[keys.length] = segment[1];
     }
     if (segment) {
       if (options.strictDepth === true) {
         throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
       }
-      keys.push("[" + key.slice(segment.index) + "]");
+      keys[keys.length] = "[" + key.slice(segment.index) + "]";
     }
     return keys;
   };
@@ -21535,6 +21568,7 @@ var require_parse = __commonJS((exports, module) => {
       parseArrays: opts.parseArrays !== false,
       plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects,
       strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults.strictDepth,
+      strictMerge: typeof opts.strictMerge === "boolean" ? !!opts.strictMerge : defaults.strictMerge,
       strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling,
       throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
     };
@@ -23205,17 +23239,8 @@ var require_dist = __commonJS((exports) => {
   var NOOP_VALUE = (value) => value;
   var ID_START = /^[$_\p{ID_Start}]$/u;
   var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-  var SIMPLE_TOKENS = {
-    "{": "{",
-    "}": "}",
-    "(": "(",
-    ")": ")",
-    "[": "[",
-    "]": "]",
-    "+": "+",
-    "?": "?",
-    "!": "!"
-  };
+  var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
+  var SIMPLE_TOKENS = "{}()[]+?!";
   function escapeText(str) {
     return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
   }
@@ -23256,8 +23281,8 @@ var require_dist = __commonJS((exports) => {
         } while (ID_CONTINUE.test(chars[index]));
       } else if (chars[index] === '"') {
         let quoteStart = index;
-        while (index++ < chars.length) {
-          if (chars[index] === '"') {
+        while (index < chars.length) {
+          if (chars[++index] === '"') {
             index++;
             quoteStart = 0;
             break;
@@ -23276,18 +23301,17 @@ var require_dist = __commonJS((exports) => {
       return value;
     }
     while (index < chars.length) {
-      const value = chars[index];
-      const type = SIMPLE_TOKENS[value];
-      if (type) {
-        tokens.push({ type, index: index++, value });
+      const value = chars[index++];
+      if (SIMPLE_TOKENS.includes(value)) {
+        tokens.push({ type: value, index, value });
       } else if (value === "\\") {
-        tokens.push({ type: "escape", index: index++, value: chars[index++] });
+        tokens.push({ type: "escape", index, value: chars[index++] });
       } else if (value === ":") {
-        tokens.push({ type: "param", index: index++, value: name() });
+        tokens.push({ type: "param", index, value: name() });
       } else if (value === "*") {
-        tokens.push({ type: "wildcard", index: index++, value: name() });
+        tokens.push({ type: "wildcard", index, value: name() });
       } else {
-        tokens.push({ type: "char", index: index++, value });
+        tokens.push({ type: "char", index, value });
       }
     }
     tokens.push({ type: "end", index, value: "" });
@@ -23424,106 +23448,129 @@ var require_dist = __commonJS((exports) => {
   function pathToRegexp(path, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
     const keys = [];
-    const flags = sensitive ? "" : "i";
     const sources = [];
-    for (const input of pathsToArray(path, [])) {
-      const data = typeof input === "object" ? input : parse5(input, options);
-      for (const tokens of flatten(data.tokens, 0, [])) {
-        sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
+    const paths = [path];
+    let combinations = 0;
+    while (paths.length) {
+      const path2 = paths.shift();
+      if (Array.isArray(path2)) {
+        paths.push(...path2);
+        continue;
       }
+      const data = typeof path2 === "object" ? path2 : parse5(path2, options);
+      flatten(data.tokens, 0, [], (tokens) => {
+        if (combinations++ >= 256) {
+          throw new PathError("Too many path combinations", data.originalPath);
+        }
+        sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
+      });
     }
     let pattern = `^(?:${sources.join("|")})`;
     if (trailing)
-      pattern += `(?:${escape2(delimiter)}$)?`;
-    pattern += end ? "$" : `(?=${escape2(delimiter)}|$)`;
-    const regexp = new RegExp(pattern, flags);
-    return { regexp, keys };
-  }
-  function pathsToArray(paths, init) {
-    if (Array.isArray(paths)) {
-      for (const p of paths)
-        pathsToArray(p, init);
-    } else {
-      init.push(paths);
-    }
-    return init;
+      pattern += "(?:" + escape2(delimiter) + "$)?";
+    pattern += end ? "$" : "(?=" + escape2(delimiter) + "|$)";
+    return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
   }
-  function* flatten(tokens, index, init) {
-    if (index === tokens.length) {
-      return yield init;
-    }
-    const token = tokens[index];
-    if (token.type === "group") {
-      for (const seq of flatten(token.tokens, 0, init.slice())) {
-        yield* flatten(tokens, index + 1, seq);
+  function flatten(tokens, index, result, callback) {
+    while (index < tokens.length) {
+      const token = tokens[index++];
+      if (token.type === "group") {
+        flatten(token.tokens, 0, result.slice(), (seq) => flatten(tokens, index, seq, callback));
+        continue;
       }
-    } else {
-      init.push(token);
+      result.push(token);
     }
-    yield* flatten(tokens, index + 1, init);
+    callback(result);
   }
   function toRegExpSource(tokens, delimiter, keys, originalPath) {
     let result = "";
     let backtrack = "";
-    let isSafeSegmentParam = true;
-    for (const token of tokens) {
+    let wildcardBacktrack = "";
+    let prevCaptureType = 0;
+    let hasSegmentCapture = 0;
+    let index = 0;
+    function hasInSegment(index2, type) {
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type === type)
+          return true;
+        if (token.type === "text") {
+          if (token.value.includes(delimiter))
+            break;
+        }
+      }
+      return false;
+    }
+    function peekText(index2) {
+      let result2 = "";
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type !== "text")
+          break;
+        result2 += token.value;
+      }
+      return result2;
+    }
+    while (index < tokens.length) {
+      const token = tokens[index++];
       if (token.type === "text") {
         result += escape2(token.value);
         backtrack += token.value;
-        isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+        if (prevCaptureType === 2)
+          wildcardBacktrack += token.value;
+        if (token.value.includes(delimiter))
+          hasSegmentCapture = 0;
         continue;
       }
       if (token.type === "param" || token.type === "wildcard") {
-        if (!isSafeSegmentParam && !backtrack) {
+        if (prevCaptureType && !backtrack) {
           throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
         }
         if (token.type === "param") {
-          result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+          result += hasSegmentCapture & 2 ? `(${negate(delimiter, backtrack)}+)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+)` : hasSegmentCapture & 1 ? `(${negate(delimiter, backtrack)}+|${escape2(backtrack)})` : `(${negate(delimiter, "")}+)`;
+          hasSegmentCapture |= prevCaptureType = 1;
         } else {
-          result += `([\\s\\S]+)`;
+          result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
+          wildcardBacktrack = "";
+          hasSegmentCapture |= prevCaptureType = 2;
         }
         keys.push(token);
         backtrack = "";
-        isSafeSegmentParam = false;
         continue;
       }
+      throw new TypeError(`Unknown token type: ${token.type}`);
     }
     return result;
   }
-  function negate(delimiter, backtrack) {
-    if (backtrack.length < 2) {
-      if (delimiter.length < 2)
-        return `[^${escape2(delimiter + backtrack)}]`;
-      return `(?:(?!${escape2(delimiter)})[^${escape2(backtrack)}])`;
-    }
-    if (delimiter.length < 2) {
-      return `(?:(?!${escape2(backtrack)})[^${escape2(delimiter)}])`;
-    }
-    return `(?:(?!${escape2(backtrack)}|${escape2(delimiter)})[\\s\\S])`;
-  }
-  function stringifyTokens(tokens) {
+  function negate(a, b) {
+    if (b.length > a.length)
+      return negate(b, a);
+    if (a === b)
+      b = "";
+    if (b.length > 1)
+      return `(?:(?!${escape2(a)}|${escape2(b)})[^])`;
+    if (a.length > 1)
+      return `(?:(?!${escape2(a)})[^${escape2(b)}])`;
+    return `[^${escape2(a + b)}]`;
+  }
+  function stringifyTokens(tokens, index) {
     let value = "";
-    let i = 0;
-    function name(value2) {
-      const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
-      return isSafe ? value2 : JSON.stringify(value2);
-    }
-    while (i < tokens.length) {
-      const token = tokens[i++];
+    while (index < tokens.length) {
+      const token = tokens[index++];
       if (token.type === "text") {
         value += escapeText(token.value);
         continue;
       }
       if (token.type === "group") {
-        value += `{${stringifyTokens(token.tokens)}}`;
+        value += "{" + stringifyTokens(token.tokens, 0) + "}";
         continue;
       }
       if (token.type === "param") {
-        value += `:${name(token.name)}`;
+        value += ":" + stringifyName(token.name, tokens[index]);
         continue;
       }
       if (token.type === "wildcard") {
-        value += `*${name(token.name)}`;
+        value += "*" + stringifyName(token.name, tokens[index]);
         continue;
       }
       throw new TypeError(`Unknown token type: ${token.type}`);
@@ -23531,16 +23578,15 @@ var require_dist = __commonJS((exports) => {
     return value;
   }
   function stringify(data) {
-    return stringifyTokens(data.tokens);
-  }
-  function isNameSafe(name) {
-    const [first, ...rest] = name;
-    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
+    return stringifyTokens(data.tokens, 0);
   }
-  function isNextNameSafe(token) {
-    if (token && token.type === "text")
-      return !ID_CONTINUE.test(token.value[0]);
-    return true;
+  function stringifyName(name, next) {
+    if (!ID.test(name))
+      return JSON.stringify(name);
+    if ((next === null || next === undefined ? undefined : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+      return JSON.stringify(name);
+    }
+    return name;
   }
 });
 
@@ -32072,7 +32118,7 @@ var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || t
 var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
 var TaskCreationParamsSchema = looseObject({
-  ttl: union([number2(), _null3()]).optional(),
+  ttl: number2().optional(),
   pollInterval: number2().optional()
 });
 var TaskMetadataSchema = object({
@@ -32224,7 +32270,8 @@ var ClientCapabilitiesSchema = object({
   roots: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ClientTasksCapabilitySchema.optional()
+  tasks: ClientTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   protocolVersion: string2(),
@@ -32250,7 +32297,8 @@ var ServerCapabilitiesSchema = object({
   tools: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ServerTasksCapabilitySchema.optional()
+  tasks: ServerTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: string2(),
@@ -32365,6 +32413,7 @@ var ResourceSchema = object({
   uri: string2(),
   description: optional(string2()),
   mimeType: optional(string2()),
+  size: optional(number2()),
   annotations: AnnotationsSchema.optional(),
   _meta: optional(looseObject({}))
 });
@@ -33555,6 +33604,7 @@ var getRequestListener = (fetchCallback, options = {}) => {
 class WebStandardStreamableHTTPServerTransport {
   constructor(options = {}) {
     this._started = false;
+    this._hasHandledRequest = false;
     this._streamMapping = new Map;
     this._requestToStreamMapping = new Map;
     this._requestResponseMap = new Map;
@@ -33617,6 +33667,10 @@ class WebStandardStreamableHTTPServerTransport {
     return;
   }
   async handleRequest(req, options) {
+    if (!this.sessionIdGenerator && this._hasHandledRequest) {
+      throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
+    }
+    this._hasHandledRequest = true;
     const validationError = this.validateRequestHeaders(req);
     if (validationError) {
       return validationError;
@@ -33656,6 +33710,7 @@ data:
   async handleGetRequest(req) {
     const acceptHeader = req.headers.get("accept");
     if (!acceptHeader?.includes("text/event-stream")) {
+      this.onerror?.(new Error("Not Acceptable: Client must accept text/event-stream"));
       return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept text/event-stream");
     }
     const sessionError = this.validateSession(req);
@@ -33673,6 +33728,7 @@ data:
       }
     }
     if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {
+      this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
       return this.createJsonErrorResponse(409, -32000, "Conflict: Only one SSE stream is allowed per session");
     }
     const encoder = new TextEncoder;
@@ -33707,6 +33763,7 @@ data:
   }
   async replayEvents(lastEventId) {
     if (!this._eventStore) {
+      this.onerror?.(new Error("Event store not configured"));
       return this.createJsonErrorResponse(400, -32000, "Event store not configured");
     }
     try {
@@ -33714,9 +33771,11 @@ data:
       if (this._eventStore.getStreamIdForEventId) {
         streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
         if (!streamId) {
+          this.onerror?.(new Error("Invalid event ID format"));
           return this.createJsonErrorResponse(400, -32000, "Invalid event ID format");
         }
         if (this._streamMapping.get(streamId) !== undefined) {
+          this.onerror?.(new Error("Conflict: Stream already has an active connection"));
           return this.createJsonErrorResponse(409, -32000, "Conflict: Stream already has an active connection");
         }
       }
@@ -33776,11 +33835,13 @@ data:
 `;
       controller.enqueue(encoder.encode(eventData));
       return true;
-    } catch {
+    } catch (error2) {
+      this.onerror?.(error2);
       return false;
     }
   }
   handleUnsupportedRequest() {
+    this.onerror?.(new Error("Method not allowed."));
     return new Response(JSON.stringify({
       jsonrpc: "2.0",
       error: {
@@ -33800,14 +33861,17 @@ data:
     try {
       const acceptHeader = req.headers.get("accept");
       if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+        this.onerror?.(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
         return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept both application/json and text/event-stream");
       }
       const ct = req.headers.get("content-type");
       if (!ct || !ct.includes("application/json")) {
+        this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
         return this.createJsonErrorResponse(415, -32000, "Unsupported Media Type: Content-Type must be application/json");
       }
       const requestInfo = {
-        headers: Object.fromEntries(req.headers.entries())
+        headers: Object.fromEntries(req.headers.entries()),
+        url: new URL(req.url)
       };
       let rawMessage;
       if (options?.parsedBody !== undefined) {
@@ -33816,6 +33880,7 @@ data:
         try {
           rawMessage = await req.json();
         } catch {
+          this.onerror?.(new Error("Parse error: Invalid JSON"));
           return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
         }
       }
@@ -33827,14 +33892,17 @@ data:
           messages = [JSONRPCMessageSchema.parse(rawMessage)];
         }
       } catch {
+        this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
         return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
       }
       const isInitializationRequest = messages.some(isInitializeRequest);
       if (isInitializationRequest) {
         if (this._initialized && this.sessionId !== undefined) {
+          this.onerror?.(new Error("Invalid Request: Server already initialized"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
         }
         if (messages.length > 1) {
+          this.onerror?.(new Error("Invalid Request: Only one initialization request is allowed"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
         }
         this.sessionId = this.sessionIdGenerator?.();
@@ -33952,13 +34020,16 @@ data:
       return;
     }
     if (!this._initialized) {
+      this.onerror?.(new Error("Bad Request: Server not initialized"));
       return this.createJsonErrorResponse(400, -32000, "Bad Request: Server not initialized");
     }
     const sessionId = req.headers.get("mcp-session-id");
     if (!sessionId) {
+      this.onerror?.(new Error("Bad Request: Mcp-Session-Id header is required"));
       return this.createJsonErrorResponse(400, -32000, "Bad Request: Mcp-Session-Id header is required");
     }
     if (sessionId !== this.sessionId) {
+      this.onerror?.(new Error("Session not found"));
       return this.createJsonErrorResponse(404, -32001, "Session not found");
     }
     return;
@@ -33966,6 +34037,7 @@ data:
   validateProtocolVersion(req) {
     const protocolVersion = req.headers.get("mcp-protocol-version");
     if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+      this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion}` + ` (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
       return this.createJsonErrorResponse(400, -32000, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
     }
     return;
@@ -34071,7 +34143,7 @@ class StreamableHTTPServerTransport {
         authInfo: context?.authInfo,
         parsedBody: context?.parsedBody
       });
-    });
+    }, { overrideGlobalObjects: false });
   }
   get sessionId() {
     return this._webStandardTransport.sessionId;
@@ -34110,7 +34182,7 @@ class StreamableHTTPServerTransport {
         authInfo,
         parsedBody
       });
-    });
+    }, { overrideGlobalObjects: false });
     await handler(req, res);
   }
   closeSSEStream(requestId) {