@mcpc-tech/cli 0.1.49 → 0.1.51

package/server.mjs

@@ -1,3 +1,5 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3031,6 +3033,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, -32e3, "Not Acceptable: Client must accept text/event-stream");
     }
     const sessionError = this.validateSession(req);
@@ -3048,6 +3051,7 @@ data:
       }
     }
     if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
+      this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
       return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
     }
     const encoder2 = new TextEncoder();
@@ -3087,6 +3091,7 @@ data:
    */
   async replayEvents(lastEventId) {
     if (!this._eventStore) {
+      this.onerror?.(new Error("Event store not configured"));
       return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
     }
     try {
@@ -3094,9 +3099,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, -32e3, "Invalid event ID format");
         }
         if (this._streamMapping.get(streamId) !== void 0) {
+          this.onerror?.(new Error("Conflict: Stream already has an active connection"));
           return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
         }
       }
@@ -3162,7 +3169,8 @@ data:
 `;
       controller.enqueue(encoder2.encode(eventData));
       return true;
-    } catch {
+    } catch (error) {
+      this.onerror?.(error);
       return false;
     }
   }
@@ -3170,6 +3178,7 @@ data:
    * Handles unsupported requests (PUT, PATCH, etc.)
    */
   handleUnsupportedRequest() {
+    this.onerror?.(new Error("Method not allowed."));
     return new Response(JSON.stringify({
       jsonrpc: "2.0",
       error: {
@@ -3192,14 +3201,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, -32e3, "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, -32e3, "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 !== void 0) {
@@ -3208,6 +3220,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");
         }
       }
@@ -3219,14 +3232,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 !== void 0) {
+          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?.();
@@ -3352,13 +3368,16 @@ data:
       return void 0;
     }
     if (!this._initialized) {
+      this.onerror?.(new Error("Bad Request: Server not initialized"));
       return this.createJsonErrorResponse(400, -32e3, "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, -32e3, "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 void 0;
@@ -3379,6 +3398,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, -32e3, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
     }
     return void 0;
@@ -3585,7 +3605,7 @@ var StreamableHTTPServerTransport = class {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/std__cli/parse_args.js
-var FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.+?))?$/s;
+var FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.*))?$/s;
 var LETTER_REGEXP = /[A-Za-z]/;
 var NUMBER_REGEXP = /-?\d+(\.\d*)?(e-?\d+)?$/;
 var HYPHEN_REGEXP = /^(-|--)[^-]/;
@@ -3596,12 +3616,19 @@ var NON_WHITESPACE_REGEXP = /\S/;
 function isNumber(string3) {
   return NON_WHITESPACE_REGEXP.test(string3) && Number.isFinite(Number(string3));
 }
+function isConstructorOrProto(obj, key) {
+  return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+}
 function setNested(object5, keys, value, collect = false) {
   keys = [
     ...keys
   ];
   const key = keys.pop();
-  keys.forEach((key2) => object5 = object5[key2] ??= {});
+  for (const k of keys) {
+    if (isConstructorOrProto(object5, k)) return;
+    object5 = object5[k] ??= {};
+  }
+  if (isConstructorOrProto(object5, key)) return;
   if (collect) {
     const v = object5[key];
     if (Array.isArray(v)) {
@@ -3732,7 +3759,7 @@ function parseArgs(args, options) {
       let key = groups.key;
       let value = groups.value;
       if (doubleDash2) {
-        if (value) {
+        if (value != null) {
           if (booleanSet.has(key)) value = parseBooleanString(value);
           setArgument(key, value, arg, true);
           continue;
@@ -3770,6 +3797,10 @@ function parseArgs(args, options) {
           setArgument(letter, next, arg, true);
           continue;
         }
+        if (next === "=") {
+          setArgument(letter, "", arg, true);
+          continue argsLoop;
+        }
         if (LETTER_REGEXP.test(letter)) {
           const groups2 = VALUE_REGEXP.exec(next)?.groups;
           if (groups2) {
@@ -4264,7 +4295,7 @@ Usage:
 - ${toolName}({ skill: "skill-name" }) - Load main SKILL.md content
 - ${toolName}({ skill: "skill-name", ref: "path/to/file" }) - Load reference file
 
-Note: For scripts/ and assets/, use appropriate tools directly.`;
+Note: For scripts/, use the bash tool with the script path to execute.`;
 }
 function createSkillsPlugin(options) {
   const { paths } = options;
@@ -4372,11 +4403,15 @@ Available skills: ${available.join(", ")}` : "\n\nNo skills available.";
           try {
             const content = await readFile(join2(meta.basePath, "SKILL.md"), "utf-8");
             const body = extractBody(content);
+            const skillPathInfo = `
+---
+Skill path: ${meta.basePath}
+`;
             return {
               content: [
                 {
                   type: "text",
-                  text: body
+                  text: body + skillPathInfo
                 }
               ]
             };
@@ -5247,12 +5282,29 @@ function writeFoldedLines(count) {
   if (count > 1) return "\n".repeat(count - 1);
   return "";
 }
+var Scanner = class {
+  source;
+  #length;
+  position = 0;
+  constructor(source) {
+    source += "\0";
+    this.source = source;
+    this.#length = source.length;
+  }
+  peek(offset = 0) {
+    return this.source.charCodeAt(this.position + offset);
+  }
+  next() {
+    this.position += 1;
+  }
+  eof() {
+    return this.position >= this.#length - 1;
+  }
+};
 var LoaderState = class {
-  input;
-  length;
+  #scanner;
   lineIndent = 0;
   lineStart = 0;
-  position = 0;
   line = 0;
   onWarning;
   allowDuplicateKeys;
@@ -5262,44 +5314,40 @@ var LoaderState = class {
   tagMap = /* @__PURE__ */ new Map();
   anchorMap = /* @__PURE__ */ new Map();
   constructor(input, { schema = DEFAULT_SCHEMA, onWarning, allowDuplicateKeys = false }) {
-    this.input = input;
+    this.#scanner = new Scanner(input);
     this.onWarning = onWarning;
     this.allowDuplicateKeys = allowDuplicateKeys;
     this.implicitTypes = schema.implicitTypes;
     this.typeMap = schema.typeMap;
-    this.length = input.length;
     this.readIndent();
   }
   skipWhitespaces() {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (isWhiteSpace(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
   }
   skipComment() {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== SHARP) return;
-    ch = this.next();
+    this.#scanner.next();
+    ch = this.#scanner.peek();
     while (ch !== 0 && !isEOL(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
   }
   readIndent() {
-    let char = this.peek();
-    while (char === SPACE) {
+    let ch = this.#scanner.peek();
+    while (ch === SPACE) {
       this.lineIndent += 1;
-      char = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
   }
-  peek(offset = 0) {
-    return this.input.charCodeAt(this.position + offset);
-  }
-  next() {
-    this.position += 1;
-    return this.peek();
-  }
   #createError(message) {
-    const mark = markToString(this.input, this.position, this.line, this.position - this.lineStart);
+    const mark = markToString(this.#scanner.source, this.#scanner.position, this.line, this.#scanner.position - this.lineStart);
     return new SyntaxError(`${message} ${mark}`);
   }
   dispatchWarning(message) {
@@ -5344,7 +5392,7 @@ var LoaderState = class {
   }
   captureSegment(start, end, checkJson) {
     if (start < end) {
-      const result = this.input.slice(start, end);
+      const result = this.#scanner.source.slice(start, end);
       if (checkJson) {
         for (let position = 0; position < result.length; position++) {
           const character = result.charCodeAt(position);
@@ -5362,21 +5410,21 @@ var LoaderState = class {
     let detected = false;
     const result = [];
     if (anchor !== null) this.anchorMap.set(anchor, result);
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
       if (ch !== MINUS) {
         break;
       }
-      const following = this.peek(1);
+      const following = this.#scanner.peek(1);
       if (!isWhiteSpaceOrEOL(following)) {
         break;
       }
       detected = true;
-      this.position++;
+      this.#scanner.next();
       if (this.skipSeparationSpace(true, -1)) {
         if (this.lineIndent <= nodeIndent) {
           result.push(null);
-          ch = this.peek();
+          ch = this.#scanner.peek();
           continue;
         }
       }
@@ -5389,7 +5437,7 @@ var LoaderState = class {
       });
       if (newState) result.push(newState.result);
       this.skipSeparationSpace(true, -1);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if ((this.line === line || this.lineIndent > nodeIndent) && ch !== 0) {
         throw this.#createError("Cannot read block sequence: bad indentation of a sequence entry");
       } else if (this.lineIndent < nodeIndent) {
@@ -5445,7 +5493,7 @@ var LoaderState = class {
     } else {
       if (!this.allowDuplicateKeys && !overridableKeys.has(keyNode) && Object.hasOwn(result, keyNode)) {
         this.line = startLine || this.line;
-        this.position = startPos || this.position;
+        this.#scanner.position = startPos || this.#scanner.position;
         throw this.#createError("Cannot store mapping pair: duplicated key");
       }
       Object.defineProperty(result, keyNode, {
@@ -5459,37 +5507,37 @@ var LoaderState = class {
     return result;
   }
   readLineBreak() {
-    const ch = this.peek();
+    const ch = this.#scanner.peek();
     if (ch === LINE_FEED) {
-      this.position++;
+      this.#scanner.next();
     } else if (ch === CARRIAGE_RETURN) {
-      this.position++;
-      if (this.peek() === LINE_FEED) {
-        this.position++;
+      this.#scanner.next();
+      if (this.#scanner.peek() === LINE_FEED) {
+        this.#scanner.next();
       }
     } else {
       throw this.#createError("Cannot read line: line break not found");
     }
     this.line += 1;
-    this.lineStart = this.position;
+    this.lineStart = this.#scanner.position;
   }
   skipSeparationSpace(allowComments, checkIndent) {
     let lineBreaks = 0;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
       this.skipWhitespaces();
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (allowComments) {
         this.skipComment();
-        ch = this.peek();
+        ch = this.#scanner.peek();
       }
       if (isEOL(ch)) {
         this.readLineBreak();
-        ch = this.peek();
+        ch = this.#scanner.peek();
         lineBreaks++;
         this.lineIndent = 0;
         this.readIndent();
-        ch = this.peek();
+        ch = this.#scanner.peek();
       } else {
         break;
       }
@@ -5500,9 +5548,9 @@ var LoaderState = class {
     return lineBreaks;
   }
   testDocumentSeparator() {
-    let ch = this.peek();
-    if ((ch === MINUS || ch === DOT) && ch === this.peek(1) && ch === this.peek(2)) {
-      ch = this.peek(3);
+    let ch = this.#scanner.peek();
+    if ((ch === MINUS || ch === DOT) && ch === this.#scanner.peek(1) && ch === this.#scanner.peek(2)) {
+      ch = this.#scanner.peek(3);
       if (ch === 0 || isWhiteSpaceOrEOL(ch)) {
         return true;
       }
@@ -5510,34 +5558,34 @@ var LoaderState = class {
     return false;
   }
   readPlainScalar(tag, anchor, nodeIndent, withinFlowCollection) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (isWhiteSpaceOrEOL(ch) || isFlowIndicator(ch) || ch === SHARP || ch === AMPERSAND || ch === ASTERISK || ch === EXCLAMATION || ch === VERTICAL_LINE || ch === GREATER_THAN || ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE || ch === PERCENT || ch === COMMERCIAL_AT || ch === GRAVE_ACCENT) {
       return;
     }
     let following;
     if (ch === QUESTION || ch === MINUS) {
-      following = this.peek(1);
+      following = this.#scanner.peek(1);
       if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
         return;
       }
     }
     let result = "";
-    let captureEnd = this.position;
-    let captureStart = this.position;
+    let captureEnd = this.#scanner.position;
+    let captureStart = this.#scanner.position;
     let hasPendingContent = false;
     let line = 0;
     while (ch !== 0) {
       if (ch === COLON) {
-        following = this.peek(1);
+        following = this.#scanner.peek(1);
         if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
           break;
         }
       } else if (ch === SHARP) {
-        const preceding = this.peek(-1);
+        const preceding = this.#scanner.peek(-1);
         if (isWhiteSpaceOrEOL(preceding)) {
           break;
         }
-      } else if (this.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) {
+      } else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) {
         break;
       } else if (isEOL(ch)) {
         line = this.line;
@@ -5546,10 +5594,10 @@ var LoaderState = class {
         this.skipSeparationSpace(false, -1);
         if (this.lineIndent >= nodeIndent) {
           hasPendingContent = true;
-          ch = this.peek();
+          ch = this.#scanner.peek();
           continue;
         } else {
-          this.position = captureEnd;
+          this.#scanner.position = captureEnd;
           this.line = line;
           this.lineStart = lineStart;
           this.lineIndent = lineIndent;
@@ -5560,13 +5608,14 @@ var LoaderState = class {
         const segment2 = this.captureSegment(captureStart, captureEnd, false);
         if (segment2) result += segment2;
         result += writeFoldedLines(this.line - line);
-        captureStart = captureEnd = this.position;
+        captureStart = captureEnd = this.#scanner.position;
         hasPendingContent = false;
       }
       if (!isWhiteSpace(ch)) {
-        captureEnd = this.position + 1;
+        captureEnd = this.#scanner.position + 1;
       }
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
     const segment = this.captureSegment(captureStart, captureEnd, false);
     if (segment) result += segment;
@@ -5579,22 +5628,23 @@ var LoaderState = class {
     };
   }
   readSingleQuotedScalar(tag, anchor, nodeIndent) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== SINGLE_QUOTE) return;
     let result = "";
-    this.position++;
-    let captureStart = this.position;
-    let captureEnd = this.position;
-    ch = this.peek();
+    this.#scanner.next();
+    let captureStart = this.#scanner.position;
+    let captureEnd = this.#scanner.position;
+    ch = this.#scanner.peek();
     while (ch !== 0) {
       if (ch === SINGLE_QUOTE) {
-        const segment = this.captureSegment(captureStart, this.position, true);
+        const segment = this.captureSegment(captureStart, this.#scanner.position, true);
         if (segment) result += segment;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
         if (ch === SINGLE_QUOTE) {
-          captureStart = this.position;
-          this.position++;
-          captureEnd = this.position;
+          captureStart = this.#scanner.position;
+          this.#scanner.next();
+          captureEnd = this.#scanner.position;
         } else {
           if (anchor !== null) this.anchorMap.set(anchor, result);
           return {
@@ -5608,31 +5658,31 @@ var LoaderState = class {
         const segment = this.captureSegment(captureStart, captureEnd, true);
         if (segment) result += segment;
         result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
-        captureStart = captureEnd = this.position;
-      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        captureStart = captureEnd = this.#scanner.position;
+      } else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) {
         throw this.#createError("Unexpected end of the document within a single quoted scalar");
       } else {
-        this.position++;
-        captureEnd = this.position;
+        this.#scanner.next();
+        captureEnd = this.#scanner.position;
       }
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     throw this.#createError("Unexpected end of the stream within a single quoted scalar");
   }
   readDoubleQuotedScalar(tag, anchor, nodeIndent) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== DOUBLE_QUOTE) return;
     let result = "";
-    this.position++;
-    let captureEnd = this.position;
-    let captureStart = this.position;
+    this.#scanner.next();
+    let captureEnd = this.#scanner.position;
+    let captureStart = this.#scanner.position;
     let tmp;
-    ch = this.peek();
+    ch = this.#scanner.peek();
     while (ch !== 0) {
       if (ch === DOUBLE_QUOTE) {
-        const segment = this.captureSegment(captureStart, this.position, true);
+        const segment = this.captureSegment(captureStart, this.#scanner.position, true);
         if (segment) result += segment;
-        this.position++;
+        this.#scanner.next();
         if (anchor !== null) this.anchorMap.set(anchor, result);
         return {
           tag,
@@ -5642,19 +5692,21 @@ var LoaderState = class {
         };
       }
       if (ch === BACKSLASH) {
-        const segment = this.captureSegment(captureStart, this.position, true);
+        const segment = this.captureSegment(captureStart, this.#scanner.position, true);
         if (segment) result += segment;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
         if (isEOL(ch)) {
           this.skipSeparationSpace(false, nodeIndent);
         } else if (ch < 256 && SIMPLE_ESCAPE_SEQUENCES.has(ch)) {
           result += SIMPLE_ESCAPE_SEQUENCES.get(ch);
-          this.position++;
+          this.#scanner.next();
         } else if ((tmp = ESCAPED_HEX_LENGTHS.get(ch) ?? 0) > 0) {
           let hexLength = tmp;
           let hexResult = 0;
           for (; hexLength > 0; hexLength--) {
-            ch = this.next();
+            this.#scanner.next();
+            ch = this.#scanner.peek();
             if ((tmp = hexCharCodeToNumber(ch)) >= 0) {
               hexResult = (hexResult << 4) + tmp;
             } else {
@@ -5662,28 +5714,28 @@ var LoaderState = class {
             }
           }
           result += codepointToChar(hexResult);
-          this.position++;
+          this.#scanner.next();
         } else {
           throw this.#createError("Cannot read double quoted scalar: unknown escape sequence");
         }
-        captureStart = captureEnd = this.position;
+        captureStart = captureEnd = this.#scanner.position;
       } else if (isEOL(ch)) {
         const segment = this.captureSegment(captureStart, captureEnd, true);
         if (segment) result += segment;
         result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
-        captureStart = captureEnd = this.position;
-      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        captureStart = captureEnd = this.#scanner.position;
+      } else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) {
         throw this.#createError("Unexpected end of the document within a double quoted scalar");
       } else {
-        this.position++;
-        captureEnd = this.position;
+        this.#scanner.next();
+        captureEnd = this.#scanner.position;
       }
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     throw this.#createError("Unexpected end of the stream within a double quoted scalar");
   }
   readFlowCollection(tag, anchor, nodeIndent) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     let terminator;
     let isMapping = true;
     let result = {};
@@ -5697,7 +5749,8 @@ var LoaderState = class {
       return;
     }
     if (anchor !== null) this.anchorMap.set(anchor, result);
-    ch = this.next();
+    this.#scanner.next();
+    ch = this.#scanner.peek();
     let readNext = true;
     let valueNode = null;
     let keyNode = null;
@@ -5709,9 +5762,9 @@ var LoaderState = class {
     const overridableKeys = /* @__PURE__ */ new Set();
     while (ch !== 0) {
       this.skipSeparationSpace(true, nodeIndent);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (ch === terminator) {
-        this.position++;
+        this.#scanner.next();
         const kind = isMapping ? "mapping" : "sequence";
         return {
           tag,
@@ -5726,10 +5779,10 @@ var LoaderState = class {
       keyTag = keyNode = valueNode = null;
       isPair = isExplicitPair = false;
       if (ch === QUESTION) {
-        following = this.peek(1);
+        following = this.#scanner.peek(1);
         if (isWhiteSpaceOrEOL(following)) {
           isPair = isExplicitPair = true;
-          this.position++;
+          this.#scanner.next();
           this.skipSeparationSpace(true, nodeIndent);
         }
       }
@@ -5745,10 +5798,11 @@ var LoaderState = class {
         keyNode = newState.result;
       }
       this.skipSeparationSpace(true, nodeIndent);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if ((isExplicitPair || this.line === line) && ch === COLON) {
         isPair = true;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
         this.skipSeparationSpace(true, nodeIndent);
         const newState2 = this.composeNode({
           parentIndent: nodeIndent,
@@ -5766,10 +5820,11 @@ var LoaderState = class {
         result.push(keyNode);
       }
       this.skipSeparationSpace(true, nodeIndent);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (ch === COMMA) {
         readNext = true;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       } else {
         readNext = false;
       }
@@ -5785,7 +5840,7 @@ var LoaderState = class {
     let textIndent = nodeIndent;
     let emptyLines = 0;
     let atMoreIndented = false;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     let folding = false;
     if (ch === VERTICAL_LINE) {
       folding = false;
@@ -5797,7 +5852,8 @@ var LoaderState = class {
     let result = "";
     let tmp = 0;
     while (ch !== 0) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
       if (ch === PLUS || ch === MINUS) {
         if (CHOMPING_CLIP === chomping) {
           chomping = ch === PLUS ? CHOMPING_KEEP : CHOMPING_STRIP;
@@ -5820,15 +5876,16 @@ var LoaderState = class {
     if (isWhiteSpace(ch)) {
       this.skipWhitespaces();
       this.skipComment();
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     while (ch !== 0) {
       this.readLineBreak();
       this.lineIndent = 0;
-      ch = this.peek();
+      ch = this.#scanner.peek();
       while ((!detectedIndent || this.lineIndent < textIndent) && ch === SPACE) {
         this.lineIndent++;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
       if (!detectedIndent && this.lineIndent > textIndent) {
         textIndent = this.lineIndent;
@@ -5867,11 +5924,12 @@ var LoaderState = class {
       didReadContent = true;
       detectedIndent = true;
       emptyLines = 0;
-      const captureStart = this.position;
+      const captureStart = this.#scanner.position;
       while (!isEOL(ch) && ch !== 0) {
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
-      const segment = this.captureSegment(captureStart, this.position, false);
+      const segment = this.captureSegment(captureStart, this.#scanner.position, false);
       if (segment) result += segment;
     }
     if (anchor !== null) this.anchorMap.set(anchor, result);
@@ -5894,11 +5952,11 @@ var LoaderState = class {
     let atExplicitKey = false;
     let detected = false;
     if (anchor !== null) this.anchorMap.set(anchor, result);
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
-      const following = this.peek(1);
+      const following = this.#scanner.peek(1);
       line = this.line;
-      pos = this.position;
+      pos = this.#scanner.position;
       if ((ch === QUESTION || ch === COLON) && isWhiteSpaceOrEOL(following)) {
         if (ch === QUESTION) {
           if (atExplicitKey) {
@@ -5916,7 +5974,7 @@ var LoaderState = class {
         } else {
           throw this.#createError("Cannot read block as explicit mapping pair is incomplete: a key node is missed or followed by a non-tabulated empty line");
         }
-        this.position += 1;
+        this.#scanner.next();
         ch = following;
       } else {
         const newState = this.composeNode({
@@ -5927,11 +5985,12 @@ var LoaderState = class {
         });
         if (!newState) break;
         if (this.line === line) {
-          ch = this.peek();
+          ch = this.#scanner.peek();
           this.skipWhitespaces();
-          ch = this.peek();
+          ch = this.#scanner.peek();
           if (ch === COLON) {
-            ch = this.next();
+            this.#scanner.next();
+            ch = this.#scanner.peek();
             if (!isWhiteSpaceOrEOL(ch)) {
               throw this.#createError("Cannot read block: a whitespace character is expected after the key-value separator within a block mapping");
             }
@@ -5988,7 +6047,7 @@ var LoaderState = class {
           keyTag = keyNode = valueNode = null;
         }
         this.skipSeparationSpace(true, -1);
-        ch = this.peek();
+        ch = this.#scanner.peek();
       }
       if (this.lineIndent > nodeIndent && ch !== 0) {
         throw this.#createError("Cannot read block: bad indentation of a mapping entry");
@@ -6011,30 +6070,35 @@ var LoaderState = class {
     let isNamed = false;
     let tagHandle = "";
     let tagName;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== EXCLAMATION) return;
     if (tag !== null) {
       throw this.#createError("Cannot read tag property: duplication of a tag property");
     }
-    ch = this.next();
+    this.#scanner.next();
+    ch = this.#scanner.peek();
     if (ch === SMALLER_THAN) {
       isVerbatim = true;
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     } else if (ch === EXCLAMATION) {
       isNamed = true;
       tagHandle = "!!";
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     } else {
       tagHandle = "!";
     }
-    let position = this.position;
+    let position = this.#scanner.position;
     if (isVerbatim) {
       do {
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       } while (ch !== 0 && ch !== GREATER_THAN);
-      if (this.position < this.length) {
-        tagName = this.input.slice(position, this.position);
-        ch = this.next();
+      if (!this.#scanner.eof()) {
+        tagName = this.#scanner.source.slice(position, this.#scanner.position);
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       } else {
         throw this.#createError("Cannot read tag property: unexpected end of stream");
       }
@@ -6042,19 +6106,20 @@ var LoaderState = class {
       while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
         if (ch === EXCLAMATION) {
           if (!isNamed) {
-            tagHandle = this.input.slice(position - 1, this.position + 1);
+            tagHandle = this.#scanner.source.slice(position - 1, this.#scanner.position + 1);
             if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
               throw this.#createError("Cannot read tag property: named tag handle contains invalid characters");
             }
             isNamed = true;
-            position = this.position + 1;
+            position = this.#scanner.position + 1;
           } else {
             throw this.#createError("Cannot read tag property: tag suffix cannot contain an exclamation mark");
           }
         }
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
-      tagName = this.input.slice(position, this.position);
+      tagName = this.#scanner.source.slice(position, this.#scanner.position);
       if (PATTERN_FLOW_INDICATORS.test(tagName)) {
         throw this.#createError("Cannot read tag property: tag suffix cannot contain flow indicator characters");
       }
@@ -6074,32 +6139,36 @@ var LoaderState = class {
     throw this.#createError(`Cannot read tag property: undeclared tag handle "${tagHandle}"`);
   }
   readAnchorProperty(anchor) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== AMPERSAND) return;
     if (anchor !== null) {
       throw this.#createError("Cannot read anchor property: duplicate anchor property");
     }
-    ch = this.next();
-    const position = this.position;
+    this.#scanner.next();
+    ch = this.#scanner.peek();
+    const position = this.#scanner.position;
     while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
-    if (this.position === position) {
+    if (this.#scanner.position === position) {
       throw this.#createError("Cannot read anchor property: name of an anchor node must contain at least one character");
     }
-    return this.input.slice(position, this.position);
+    return this.#scanner.source.slice(position, this.#scanner.position);
   }
   readAlias() {
-    if (this.peek() !== ASTERISK) return;
-    let ch = this.next();
-    const position = this.position;
+    if (this.#scanner.peek() !== ASTERISK) return;
+    this.#scanner.next();
+    let ch = this.#scanner.peek();
+    const position = this.#scanner.position;
     while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
-    if (this.position === position) {
+    if (this.#scanner.position === position) {
       throw this.#createError("Cannot read alias: alias name must contain at least one character");
     }
-    const alias = this.input.slice(position, this.position);
+    const alias = this.#scanner.source.slice(position, this.#scanner.position);
     if (!this.anchorMap.has(alias)) {
       throw this.#createError(`Cannot read alias: unidentified alias "${alias}"`);
     }
@@ -6182,7 +6251,7 @@ var LoaderState = class {
       const cond = CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext;
       const flowIndent = cond ? parentIndent : parentIndent + 1;
       if (allowBlockCollections) {
-        const blockIndent = this.position - this.lineStart;
+        const blockIndent = this.#scanner.position - this.lineStart;
         const blockSequenceState = this.readBlockSequence(tag, anchor, blockIndent);
         if (blockSequenceState) return this.resolveTag(blockSequenceState);
         const blockMappingState = this.readBlockMapping(tag, anchor, blockIndent, flowIndent);
@@ -6216,7 +6285,7 @@ var LoaderState = class {
         return this.resolveTag(plainScalarState);
       }
     } else if (indentStatus === 0 && CONTEXT_BLOCK_OUT === nodeContext && allowBlockCollections) {
-      const blockIndent = this.position - this.lineStart;
+      const blockIndent = this.#scanner.position - this.lineStart;
       const newState2 = this.readBlockSequence(tag, anchor, blockIndent);
       if (newState2) return this.resolveTag(newState2);
     }
@@ -6231,20 +6300,22 @@ var LoaderState = class {
   readDirectives() {
     let hasDirectives = false;
     let version = null;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
       this.skipSeparationSpace(true, -1);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (this.lineIndent > 0 || ch !== PERCENT) {
         break;
       }
       hasDirectives = true;
-      ch = this.next();
-      let position = this.position;
+      this.#scanner.next();
+      ch = this.#scanner.peek();
+      let position = this.#scanner.position;
       while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
-      const directiveName = this.input.slice(position, this.position);
+      const directiveName = this.#scanner.source.slice(position, this.#scanner.position);
       const directiveArgs = [];
       if (directiveName.length < 1) {
         throw this.#createError("Cannot read document: directive name length must be greater than zero");
@@ -6252,13 +6323,14 @@ var LoaderState = class {
       while (ch !== 0) {
         this.skipWhitespaces();
         this.skipComment();
-        ch = this.peek();
+        ch = this.#scanner.peek();
         if (isEOL(ch)) break;
-        position = this.position;
+        position = this.#scanner.position;
         while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
-          ch = this.next();
+          this.#scanner.next();
+          ch = this.#scanner.peek();
         }
-        directiveArgs.push(this.input.slice(position, this.position));
+        directiveArgs.push(this.#scanner.source.slice(position, this.#scanner.position));
       }
       if (ch !== 0) this.readLineBreak();
       switch (directiveName) {
@@ -6275,20 +6347,20 @@ var LoaderState = class {
           this.dispatchWarning(`unknown document directive "${directiveName}"`);
           break;
       }
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     return hasDirectives;
   }
   readDocument() {
-    const documentStart = this.position;
+    const documentStart = this.#scanner.position;
     this.checkLineBreaks = false;
     this.tagMap = /* @__PURE__ */ new Map();
     this.anchorMap = /* @__PURE__ */ new Map();
     const hasDirectives = this.readDirectives();
     this.skipSeparationSpace(true, -1);
     let result = null;
-    if (this.lineIndent === 0 && this.peek() === MINUS && this.peek(1) === MINUS && this.peek(2) === MINUS) {
-      this.position += 3;
+    if (this.lineIndent === 0 && this.#scanner.peek() === MINUS && this.#scanner.peek(1) === MINUS && this.#scanner.peek(2) === MINUS) {
+      this.#scanner.position += 3;
       this.skipSeparationSpace(true, -1);
     } else if (hasDirectives) {
       throw this.#createError("Cannot read document: directives end mark is expected");
@@ -6301,21 +6373,21 @@ var LoaderState = class {
     });
     if (newState) result = newState.result;
     this.skipSeparationSpace(true, -1);
-    if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.input.slice(documentStart, this.position))) {
+    if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.#scanner.source.slice(documentStart, this.#scanner.position))) {
       this.dispatchWarning("non-ASCII line breaks are interpreted as content");
     }
-    if (this.position === this.lineStart && this.testDocumentSeparator()) {
-      if (this.peek() === DOT) {
-        this.position += 3;
+    if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) {
+      if (this.#scanner.peek() === DOT) {
+        this.#scanner.position += 3;
         this.skipSeparationSpace(true, -1);
       }
-    } else if (this.position < this.length - 1) {
+    } else if (!this.#scanner.eof()) {
       throw this.#createError("Cannot read document: end of the stream or a document separator is expected");
     }
     return result;
   }
   *readDocuments() {
-    while (this.position < this.length - 1) {
+    while (!this.#scanner.eof()) {
       yield this.readDocument();
     }
   }
@@ -6328,7 +6400,6 @@ function sanitizeInput(input) {
     if (!isEOL(input.charCodeAt(input.length - 1))) input += "\n";
     if (input.charCodeAt(0) === 65279) input = input.slice(1);
   }
-  input += "\0";
   return input;
 }
 function parse(content, options = {}) {
@@ -6488,7 +6559,7 @@ function getDefaultAgents() {
 }
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
-var CLI_VERSION = "0.1.44";
+var CLI_VERSION = "0.1.51";
 function extractServerName(command, commandArgs) {
   for (const arg of commandArgs) {
     if (!arg.startsWith("-")) {
@@ -8158,6 +8229,147 @@ var ExperimentalServerTasks = class {
   requestStream(request, resultSchema, options) {
     return this._server.requestStream(request, resultSchema, options);
   }
+  /**
+   * Sends a sampling request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
+   * before the final result.
+   *
+   * @example
+   * ```typescript
+   * const stream = server.experimental.tasks.createMessageStream({
+   *     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
+   *     maxTokens: 100
+   * }, {
+   *     onprogress: (progress) => {
+   *         // Handle streaming tokens via progress notifications
+   *         console.log('Progress:', progress.message);
+   *     }
+   * });
+   *
+   * for await (const message of stream) {
+   *     switch (message.type) {
+   *         case 'taskCreated':
+   *             console.log('Task created:', message.task.taskId);
+   *             break;
+   *         case 'taskStatus':
+   *             console.log('Task status:', message.task.status);
+   *             break;
+   *         case 'result':
+   *             console.log('Final result:', message.result);
+   *             break;
+   *         case 'error':
+   *             console.error('Error:', message.error);
+   *             break;
+   *     }
+   * }
+   * ```
+   *
+   * @param params - The sampling request parameters
+   * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  createMessageStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+      throw new Error("Client does not support sampling tools capability.");
+    }
+    if (params.messages.length > 0) {
+      const lastMessage = params.messages[params.messages.length - 1];
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+      if (hasToolResults) {
+        if (lastContent.some((c) => c.type !== "tool_result")) {
+          throw new Error("The last message must contain only tool_result content if any is present");
+        }
+        if (!hasPreviousToolUse) {
+          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+        }
+      }
+      if (hasPreviousToolUse) {
+        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
+          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+        }
+      }
+    }
+    return this.requestStream({
+      method: "sampling/createMessage",
+      params
+    }, CreateMessageResultSchema, options);
+  }
+  /**
+   * Sends an elicitation request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
+   * and 'taskStatus' messages before the final result.
+   *
+   * @example
+   * ```typescript
+   * const stream = server.experimental.tasks.elicitInputStream({
+   *     mode: 'url',
+   *     message: 'Please authenticate',
+   *     elicitationId: 'auth-123',
+   *     url: 'https://example.com/auth'
+   * }, {
+   *     task: { ttl: 300000 } // Task-augmented for long-running auth flow
+   * });
+   *
+   * for await (const message of stream) {
+   *     switch (message.type) {
+   *         case 'taskCreated':
+   *             console.log('Task created:', message.task.taskId);
+   *             break;
+   *         case 'taskStatus':
+   *             console.log('Task status:', message.task.status);
+   *             break;
+   *         case 'result':
+   *             console.log('User action:', message.result.action);
+   *             break;
+   *         case 'error':
+   *             console.error('Error:', message.error);
+   *             break;
+   *     }
+   * }
+   * ```
+   *
+   * @param params - The elicitation request parameters
+   * @param options - Optional request options (timeout, signal, task creation params, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  elicitInputStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    const mode = params.mode ?? "form";
+    switch (mode) {
+      case "url": {
+        if (!clientCapabilities?.elicitation?.url) {
+          throw new Error("Client does not support url elicitation.");
+        }
+        break;
+      }
+      case "form": {
+        if (!clientCapabilities?.elicitation?.form) {
+          throw new Error("Client does not support form elicitation.");
+        }
+        break;
+      }
+    }
+    const normalizedParams = mode === "form" && params.mode === void 0 ? { ...params, mode: "form" } : params;
+    return this.requestStream({
+      method: "elicitation/create",
+      params: normalizedParams
+    }, ElicitResultSchema, options);
+  }
   /**
    * Gets the current status of a task.
    *
@@ -10376,22 +10588,45 @@ async function auth(provider, options) {
   }
 }
 async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+  const cachedState = await provider.discoveryState?.();
   let resourceMetadata;
   let authorizationServerUrl;
-  try {
-    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl }, fetchFn);
-    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
-      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+  let metadata;
+  let effectiveResourceMetadataUrl = resourceMetadataUrl;
+  if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) {
+    effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
+  }
+  if (cachedState?.authorizationServerUrl) {
+    authorizationServerUrl = cachedState.authorizationServerUrl;
+    resourceMetadata = cachedState.resourceMetadata;
+    metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
+    if (!resourceMetadata) {
+      try {
+        resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+      } catch {
+      }
     }
-  } catch {
-  }
-  if (!authorizationServerUrl) {
-    authorizationServerUrl = new URL("/", serverUrl);
+    if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) {
+      await provider.saveDiscoveryState?.({
+        authorizationServerUrl: String(authorizationServerUrl),
+        resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+        resourceMetadata,
+        authorizationServerMetadata: metadata
+      });
+    }
+  } else {
+    const serverInfo = await discoverOAuthServerInfo(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn });
+    authorizationServerUrl = serverInfo.authorizationServerUrl;
+    metadata = serverInfo.authorizationServerMetadata;
+    resourceMetadata = serverInfo.resourceMetadata;
+    await provider.saveDiscoveryState?.({
+      authorizationServerUrl: String(authorizationServerUrl),
+      resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+      resourceMetadata,
+      authorizationServerMetadata: metadata
+    });
   }
   const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
-  const metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
-    fetchFn
-  });
   let clientInformation = await Promise.resolve(provider.clientInformation());
   if (!clientInformation) {
     if (authorizationCode !== void 0) {
@@ -10646,6 +10881,26 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fet
   }
   return void 0;
 }
+async function discoverOAuthServerInfo(serverUrl, opts) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch {
+  }
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = String(new URL("/", serverUrl));
+  }
+  const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
+  return {
+    authorizationServerUrl,
+    authorizationServerMetadata,
+    resourceMetadata
+  };
+}
 async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
   let authorizationUrl;
   if (metadata) {
@@ -11510,18 +11765,6 @@ var cleanToolSchema = (schema) => {
 import { cwd } from "node:process";
 import process7 from "node:process";
 import { createHash } from "node:crypto";
-var mcpClientPool = /* @__PURE__ */ new Map();
-var mcpClientConnecting = /* @__PURE__ */ new Map();
-var shortHash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 8);
-function defSignature(def) {
-  const defCopy = {
-    ...def
-  };
-  if (defCopy.transportType === "memory" || defCopy.transport) {
-    return `memory:${Date.now()}:${Math.random()}`;
-  }
-  return JSON.stringify(defCopy);
-}
 function createTransport(def) {
   const defAny = def;
   const explicitType = defAny.transportType || defAny.type;
@@ -11569,90 +11812,43 @@ function createTransport(def) {
   }
   throw new Error(`Unsupported transport configuration: ${JSON.stringify(def)}`);
 }
-async function getOrCreateMcpClient(defKey, def) {
-  const pooled = mcpClientPool.get(defKey);
-  if (pooled) {
-    pooled.refCount += 1;
-    return pooled.client;
-  }
-  const existingConnecting = mcpClientConnecting.get(defKey);
-  if (existingConnecting) {
-    const client = await existingConnecting;
-    const entry = mcpClientPool.get(defKey);
-    if (entry) entry.refCount += 1;
-    return client;
-  }
-  const transport = createTransport(def);
-  const connecting = (async () => {
-    const client = new Client({
-      name: `mcp_${shortHash(defSignature(def))}`,
-      version: "1.0.0"
-    });
-    await client.connect(transport, {
-      timeout: 6e4 * 10
-    });
-    return client;
-  })();
-  mcpClientConnecting.set(defKey, connecting);
-  try {
-    const client = await connecting;
-    mcpClientPool.set(defKey, {
-      client,
-      refCount: 1
-    });
-    return client;
-  } finally {
-    mcpClientConnecting.delete(defKey);
+function defSignature(def) {
+  const defCopy = {
+    ...def
+  };
+  if (defCopy.transportType === "memory" || defCopy.transport) {
+    return `memory:${Date.now()}:${Math.random()}`;
   }
+  return JSON.stringify(defCopy);
 }
-async function releaseMcpClient(defKey) {
-  const entry = mcpClientPool.get(defKey);
-  if (!entry) return;
-  entry.refCount -= 1;
-  if (entry.refCount <= 0) {
-    mcpClientPool.delete(defKey);
-    try {
-      await entry.client.close();
-    } catch (err) {
-      console.error("Error closing MCP client:", err);
-    }
-  }
+var shortHash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 8);
+async function createMcpClient(def) {
+  const transport = createTransport(def);
+  const client = new Client({
+    name: `mcp_${shortHash(defSignature(def))}`,
+    version: "1.0.0"
+  });
+  await client.connect(transport, {
+    timeout: 6e4 * 10
+  });
+  return client;
 }
-var cleanupAllPooledClients = async () => {
-  const entries = Array.from(mcpClientPool.entries());
-  mcpClientPool.clear();
-  await Promise.all(entries.map(async ([, { client }]) => {
-    try {
-      await client.close();
-    } catch (err) {
-      console.error("Error closing MCP client:", err);
-    }
-  }));
-};
-process7.once?.("exit", () => {
-  cleanupAllPooledClients();
-});
-process7.once?.("SIGINT", () => {
-  cleanupAllPooledClients().finally(() => process7.exit(0));
-});
 async function composeMcpDepTools(mcpConfig, filterIn) {
   const allTools = {};
   const allClients = {};
-  const acquiredKeys = [];
+  const clientsToClose = [];
   for (const [name, definition] of Object.entries(mcpConfig.mcpServers)) {
     const def = definition;
     if (def.disabled) continue;
-    const defKey = shortHash(defSignature(def));
-    const serverId = name;
     try {
-      const client = await getOrCreateMcpClient(defKey, def);
-      acquiredKeys.push(defKey);
-      allClients[serverId] = client;
+      const client = await createMcpClient(def);
+      clientsToClose.push(client);
+      allClients[name] = client;
       const { tools } = await client.listTools();
       tools.forEach((tool2) => {
         const toolNameWithScope = `${name}.${tool2.name}`;
         const internalToolName = tool2.name;
-        const rawToolId = `${serverId}_${internalToolName}`;
+        const rawToolId = `${name}_${internalToolName}`;
         const toolId = sanitizePropertyKey(rawToolId);
         if (filterIn && !filterIn({
           action: internalToolName,
@@ -11664,7 +11860,7 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
         })) {
           return;
         }
-        const execute = (args) => allClients[serverId].callTool({
+        const execute = (args) => allClients[name].callTool({
           name: internalToolName,
           arguments: args
         }, void 0, {
@@ -11681,10 +11877,12 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
     }
   }
   const cleanupClients = async () => {
-    await Promise.all(acquiredKeys.map((k) => releaseMcpClient(k)));
-    acquiredKeys.length = 0;
-    Object.keys(allTools).forEach((key) => delete allTools[key]);
-    Object.keys(allClients).forEach((key) => delete allClients[key]);
+    await Promise.all(clientsToClose.map((client) => {
+      try {
+        return client.close();
+      } catch {
+      }
+    }));
   };
   return {
     tools: allTools,