@dalmia/calibrate-mcp 0.0.41 → 0.0.43

package/bin/mcp-server.js

@@ -40926,8 +40926,9 @@ var require_utils4 = __commonJS(function(exports, module) {
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
   var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
   var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-  var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
-  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/?]$/iu);
+  var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+  var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
   function stringArrayToHexStripped(input) {
     let acc = "";
     let code = 0;
@@ -40952,91 +40953,127 @@ var require_utils4 = __commonJS(function(exports, module) {
     }
     return acc;
   }
+  var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+  var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+  var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
   var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
-    return true;
+  var nonSimpleDomainChars = RegExp.prototype.test.bind(/[^\d!"$&'()*+,\-.;=_`a-z{}~]/u);
+  var numericLastLabel = RegExp.prototype.test.bind(/(?:^|\.)\d+$/u);
+  function nonSimpleMailtoDomain(domain) {
+    return nonSimpleDomainChars(domain) || numericLastLabel(domain);
   }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex = stringArrayToHexStripped(buffer);
-      if (hex !== "") {
-        address.push(hex);
-      } else {
-        output.error = true;
-        return false;
+  function isZoneIdentifier(zone) {
+    if (zone.length === 0)
+      return false;
+    for (let i = 0;i < zone.length; i++) {
+      if (isZoneCharacter(zone[i]))
+        continue;
+      if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+        i += 2;
+        continue;
       }
-      buffer.length = 0;
+      return false;
     }
     return true;
   }
-  function getIPV6(input) {
-    let tokenCount = 0;
-    const output = { error: false, address: "", zone: "" };
-    const address = [];
-    const buffer = [];
-    let endipv6Encountered = false;
-    let endIpv6 = false;
-    let consume = consumeHextets;
-    for (let i = 0;i < input.length; i++) {
-      const cursor = input[i];
-      if (cursor === "[" || cursor === "]") {
-        continue;
-      }
-      if (cursor === ":") {
-        if (endipv6Encountered === true) {
-          endIpv6 = true;
-        }
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        if (++tokenCount > 7) {
-          output.error = true;
-          break;
+  function compressIPv6ZeroRun(hextets) {
+    let bestStart = -1;
+    let bestLength = 0;
+    let runStart = -1;
+    let runLength = 0;
+    for (let i = 0;i < hextets.length; i++) {
+      if (hextets[i] === "0") {
+        if (runStart === -1)
+          runStart = i;
+        runLength++;
+        if (runLength > bestLength) {
+          bestLength = runLength;
+          bestStart = runStart;
         }
-        if (i > 0 && input[i - 1] === ":") {
-          endipv6Encountered = true;
-        }
-        address.push(":");
-        continue;
-      } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        consume = consumeIsZone;
       } else {
-        buffer.push(cursor);
-        continue;
+        runStart = -1;
+        runLength = 0;
       }
     }
-    if (buffer.length) {
-      if (consume === consumeIsZone) {
-        output.zone = buffer.join("");
-      } else if (endIpv6) {
-        address.push(buffer.join(""));
-      } else {
-        address.push(stringArrayToHexStripped(buffer));
+    if (bestLength < 2)
+      return hextets.join(":");
+    const head = hextets.slice(0, bestStart).join(":");
+    const tail = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail;
+  }
+  function normalizeIPv6Address(input) {
+    const compression = input.indexOf("::");
+    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1)
+      return;
+    const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+    const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+    if (compression !== -1) {
+      if (left.length === 1 && left[0] === "")
+        left.length = 0;
+      if (right.length === 1 && right[0] === "")
+        right.length = 0;
+    }
+    const parts = left.concat(right);
+    let hextetCount = 0;
+    for (let i = 0;i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "")
+        return;
+      if (part.indexOf(".") !== -1) {
+        if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part))
+          return;
+        hextetCount += 2;
+        continue;
       }
+      if (!isHextet(part))
+        return;
+      parts[i] = parseInt(part, 16).toString(16);
+      hextetCount++;
     }
-    output.address = address.join("");
-    return output;
+    if (compression === -1) {
+      if (hextetCount !== 8)
+        return;
+      return compressIPv6ZeroRun(parts);
+    }
+    if (hextetCount >= 8)
+      return;
+    const expanded = parts.slice(0, left.length);
+    for (let i = hextetCount;i < 8; i++)
+      expanded.push("0");
+    for (let i = left.length;i < parts.length; i++)
+      expanded.push(parts[i]);
+    return compressIPv6ZeroRun(expanded);
   }
   function normalizeIPv6(host) {
-    if (findToken(host, ":") < 2) {
-      return { host, isIPV6: false };
-    }
-    const ipv62 = getIPV6(host);
-    if (!ipv62.error) {
-      let newHost = ipv62.address;
-      let escapedHost = ipv62.address;
-      if (ipv62.zone) {
-        newHost += "%" + ipv62.zone;
-        escapedHost += "%25" + ipv62.zone;
-      }
-      return { host: newHost, isIPV6: true, escapedHost };
-    } else {
-      return { host, isIPV6: false };
-    }
+    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+    const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+    if (hasBracket && !bracketed)
+      return { host, isIPV6: false, error: true };
+    let input = bracketed ? host.slice(1, -1) : host;
+    if (bracketed && isIPvFuture(input)) {
+      input = input.toLowerCase();
+      return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+    }
+    if (findToken(input, ":") < 2) {
+      return { host, isIPV6: false, error: bracketed };
+    }
+    let zoneIdentifier = "";
+    const zoneSeparator = input.indexOf("%");
+    if (zoneSeparator !== -1) {
+      const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+      if (!isZoneIdentifier(zoneIdentifier))
+        return { host, isIPV6: false, error: true };
+      input = input.slice(0, zoneSeparator);
+    }
+    const address = normalizeIPv6Address(input);
+    if (address === undefined)
+      return { host, isIPV6: false, error: true };
+    return {
+      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+      isIPV6: true
+    };
   }
   function findToken(str, token) {
     let ind = 0;
@@ -41213,6 +41250,45 @@ var require_utils4 = __commonJS(function(exports, module) {
     }
     return output;
   }
+  function serializePathEncoding(input, pathNoScheme = false) {
+    let output = "";
+    let firstSegment = pathNoScheme && input[0] !== "/";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "/") {
+        firstSegment = false;
+      }
+      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
   function normalizeQueryFragmentEncoding(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
@@ -41254,6 +41330,50 @@ var require_utils4 = __commonJS(function(exports, module) {
     }
     return output;
   }
+  function encodeComponent(input, isAllowed) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (isAllowed(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeUserinfo(input) {
+    return encodeComponent(input, isUserinfoCharacter);
+  }
+  function encodeQuery(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function encodeFragment(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
   function escapePreservingEscapes(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
@@ -41288,14 +41408,18 @@ var require_utils4 = __commonJS(function(exports, module) {
   function recomposeAuthority(component) {
     const uriTokens = [];
     if (component.userinfo !== undefined) {
-      uriTokens.push(component.userinfo);
+      uriTokens.push(encodeUserinfo(component.userinfo));
       uriTokens.push("@");
     }
     if (component.host !== undefined) {
-      let host = unescape(component.host);
+      let host = component.host;
       if (!isIPv4(host)) {
-        const ipV6res = normalizeIPv6(host);
-        if (ipV6res.isIPV6 === true) {
+        let ipV6res = normalizeIPv6(host);
+        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+          host = normalizePercentEncoding(host, true);
+          ipV6res = normalizeIPv6(host);
+        }
+        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
           host = reescapeHostDelimiters(host, false);
@@ -41310,12 +41434,19 @@ var require_utils4 = __commonJS(function(exports, module) {
     return uriTokens.length ? uriTokens.join("") : undefined;
   }
   module.exports = {
+    BYTE_HEX,
+    percentEncodeNonAscii,
     nonSimpleDomain,
+    nonSimpleMailtoDomain,
     recomposeAuthority,
     reescapeHostDelimiters,
     normalizePercentEncoding,
     normalizePathEncoding,
+    serializePathEncoding,
     normalizeQueryFragmentEncoding,
+    encodeUserinfo,
+    encodeQuery,
+    encodeFragment,
     escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
@@ -41327,15 +41458,16 @@ var require_utils4 = __commonJS(function(exports, module) {
 
 // node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS(function(exports, module) {
-  var { isUUID } = require_utils4();
-  var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+  var { isUUID, BYTE_HEX, percentEncodeNonAscii, nonSimpleMailtoDomain } = require_utils4();
+  var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
   var supportedSchemeNames = [
     "http",
     "https",
     "ws",
     "wss",
     "urn",
-    "urn:uuid"
+    "urn:uuid",
+    "mailto"
   ];
   function isValidSchemeName(name) {
     return supportedSchemeNames.indexOf(name) !== -1;
@@ -41383,9 +41515,10 @@ var require_schemes = __commonJS(function(exports, module) {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path, query] = wsComponent.resourceName.split("?");
+      const queryIndex = wsComponent.resourceName.indexOf("?");
+      const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
       wsComponent.path = path && path !== "/" ? path : undefined;
-      wsComponent.query = query;
+      wsComponent.query = queryIndex === -1 ? undefined : wsComponent.resourceName.slice(queryIndex + 1);
       wsComponent.resourceName = undefined;
     }
     wsComponent.fragment = undefined;
@@ -41397,7 +41530,7 @@ var require_schemes = __commonJS(function(exports, module) {
       return urnComponent;
     }
     const matches = urnComponent.path.match(URN_REG);
-    if (matches) {
+    if (matches && matches[0] === urnComponent.path) {
       const scheme = options.scheme || urnComponent.scheme || "urn";
       urnComponent.nid = matches[1].toLowerCase();
       urnComponent.nss = matches[2];
@@ -41479,13 +41612,235 @@ var require_schemes = __commonJS(function(exports, module) {
     serialize: urnuuidSerialize,
     skipNormalize: true
   };
+  var LOCAL_PART_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+=";
+  var HFNAME_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+,;:@";
+  var DTEXT_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+;:";
+  function allowSet(chars, allowNonAscii = false) {
+    const table = new Uint8Array(128);
+    for (let i = 0;i < chars.length; i++) {
+      table[chars.charCodeAt(i)] = 1;
+    }
+    const escaped = chars.replace(/[\\\]^-]/gu, "\\$&");
+    const cls = allowNonAscii ? `[${escaped}]|[^\\0-\\x7F\\uD800-\\uDFFF]` : `[${escaped}]`;
+    return { all: new RegExp(`^(?:${cls})*$`, "u"), table, allowNonAscii };
+  }
+  var LOCAL_PART = allowSet(LOCAL_PART_ALLOWED);
+  var HFNAME = allowSet(HFNAME_ALLOWED);
+  var DTEXT = allowSet(DTEXT_ALLOWED);
+  var DTEXT_IRI = allowSet(DTEXT_ALLOWED, true);
+  var HEX_PAIR = /^[\da-f]{2}$/iu;
+  var MAILTO_DOMAIN_LITERAL = /^\[[\x21-\x5A\x5E-\x7E]*\]$/u;
+  var MAILTO_DOMAIN_ERROR = "URI mailto has an invalid recipient domain.";
+  var HAS_SURROGATE = /[\uD800-\uDFFF]/u;
+  function decodeHex(str) {
+    if (typeof str !== "string" || str.indexOf("%") === -1) {
+      return str;
+    }
+    try {
+      return decodeURIComponent(str);
+    } catch {
+      return str;
+    }
+  }
+  function replaceLoneSurrogates(input) {
+    let result = "";
+    for (let i = 0;i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code >= 55296 && code <= 56319 && i + 1 < input.length) {
+        const low = input.charCodeAt(i + 1);
+        if (low >= 56320 && low <= 57343) {
+          result += input[i] + input[i + 1];
+          i++;
+          continue;
+        }
+      }
+      result += code >= 55296 && code <= 57343 ? "�" : input[i];
+    }
+    return result;
+  }
+  function encodeWithAllow(input, set2) {
+    if (set2.all.test(input)) {
+      return input;
+    }
+    const table = set2.table;
+    let result = "";
+    for (let i = 0;i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code < 128) {
+        if (table[code] === 1) {
+          result += input[i];
+        } else if (code === 37 && i + 2 < input.length && HEX_PAIR.test(input.slice(i + 1, i + 3))) {
+          result += "%" + input.slice(i + 1, i + 3).toUpperCase();
+          i += 2;
+        } else {
+          result += BYTE_HEX[code];
+        }
+        continue;
+      }
+      if (code < 55296 || code > 57343) {
+        result += set2.allowNonAscii ? input[i] : percentEncodeNonAscii(code);
+        continue;
+      }
+      if (code <= 56319 && i + 1 < input.length) {
+        const low = input.charCodeAt(i + 1);
+        if (low >= 56320 && low <= 57343) {
+          result += set2.allowNonAscii ? input[i] + input[i + 1] : percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+          i++;
+          continue;
+        }
+      }
+      result += set2.allowNonAscii ? "�" : percentEncodeNonAscii(65533);
+    }
+    return result;
+  }
+  function mailtoNormalizeDomain(domain, options, component) {
+    const normalizedDomain = String(domain).toLowerCase();
+    if (MAILTO_DOMAIN_LITERAL.test(normalizedDomain)) {
+      return normalizedDomain;
+    }
+    if (normalizedDomain !== "" && !nonSimpleMailtoDomain(normalizedDomain)) {
+      return normalizedDomain;
+    }
+    try {
+      const parsedDomain = new URL("http://" + normalizedDomain);
+      if (parsedDomain.username || parsedDomain.password || parsedDomain.port || parsedDomain.pathname !== "/" || parsedDomain.search || parsedDomain.hash || !parsedDomain.hostname) {
+        throw new Error(MAILTO_DOMAIN_ERROR);
+      }
+      return options && options.unicodeSupport ? normalizedDomain : parsedDomain.hostname;
+    } catch {
+      if (component) {
+        component.error = component.error || MAILTO_DOMAIN_ERROR;
+      }
+      return normalizedDomain;
+    }
+  }
+  function mailtoEncodeDomain(domain, options) {
+    const set2 = options && options.unicodeSupport ? DTEXT_IRI : DTEXT;
+    if (domain.length > 1 && domain[0] === "[" && domain[domain.length - 1] === "]") {
+      return "[" + encodeWithAllow(domain.slice(1, -1), set2) + "]";
+    }
+    return encodeWithAllow(domain, set2);
+  }
+  function mailtoParse(component, options) {
+    const mailtoComponent = component;
+    let rawPath = mailtoComponent.path;
+    let rawQuery = mailtoComponent.query;
+    if (rawPath && HAS_SURROGATE.test(rawPath))
+      rawPath = replaceLoneSurrogates(rawPath);
+    if (rawQuery && HAS_SURROGATE.test(rawQuery))
+      rawQuery = replaceLoneSurrogates(rawQuery);
+    const to = rawPath ? rawPath.indexOf(",") === -1 ? [rawPath] : rawPath.split(",") : [];
+    mailtoComponent.path = undefined;
+    if (rawQuery) {
+      let headers = null;
+      let start = 0;
+      while (start <= rawQuery.length) {
+        let end = rawQuery.indexOf("&", start);
+        if (end === -1)
+          end = rawQuery.length;
+        const token = rawQuery.slice(start, end);
+        start = end + 1;
+        const eqIdx = token.indexOf("=");
+        if (eqIdx !== token.lastIndexOf("=")) {
+          mailtoComponent.error = mailtoComponent.error || "URI mailto has malformed header fields.";
+          continue;
+        }
+        const name = eqIdx === -1 ? token : token.slice(0, eqIdx);
+        const value = eqIdx === -1 ? "" : token.slice(eqIdx + 1);
+        if (name === "to") {
+          const addrs = value.split(",");
+          for (let j = 0;j < addrs.length; j++)
+            to.push(addrs[j]);
+          continue;
+        }
+        if (name === "subject") {
+          mailtoComponent.subject = decodeHex(value);
+          continue;
+        }
+        if (name === "body") {
+          mailtoComponent.body = decodeHex(value);
+          continue;
+        }
+        if (headers === null)
+          headers = Object.create(null);
+        headers[decodeHex(name)] = decodeHex(value);
+      }
+      if (headers !== null)
+        mailtoComponent.headers = headers;
+    }
+    mailtoComponent.query = undefined;
+    for (let i = 0;i < to.length; i++) {
+      const rawAddr = to[i];
+      const atIdx = rawAddr.lastIndexOf("@");
+      if (atIdx < 0) {
+        mailtoComponent.error = mailtoComponent.error || MAILTO_DOMAIN_ERROR;
+        to[i] = decodeHex(rawAddr);
+        continue;
+      }
+      const local = decodeHex(rawAddr.slice(0, atIdx));
+      const domain = mailtoNormalizeDomain(decodeHex(rawAddr.slice(atIdx + 1)), options, mailtoComponent);
+      to[i] = local + "@" + domain;
+    }
+    if (to.length)
+      mailtoComponent.to = to;
+    return mailtoComponent;
+  }
+  function mailtoSerialize(component, options) {
+    const mailtoComponent = component;
+    const to = Array.isArray(mailtoComponent.to) ? mailtoComponent.to.slice() : [];
+    if (to.length) {
+      for (let i = 0;i < to.length; i++) {
+        const addr = String(to[i]);
+        const atIdx = addr.lastIndexOf("@");
+        const rawLocal = atIdx >= 0 ? addr.slice(0, atIdx) : addr;
+        const rawDomain = atIdx >= 0 ? addr.slice(atIdx + 1) : "";
+        const local = encodeWithAllow(rawLocal, LOCAL_PART);
+        const decodedDomain = decodeHex(rawDomain);
+        const normalizedDomain = mailtoNormalizeDomain(decodedDomain, options);
+        to[i] = local + "@" + mailtoEncodeDomain(normalizedDomain, options);
+      }
+      mailtoComponent.path = to.join(",");
+      options.skipEscape = true;
+    } else {
+      mailtoComponent.path = undefined;
+    }
+    const headers = mailtoComponent.headers && typeof mailtoComponent.headers === "object" ? Object.assign(Object.create(null), mailtoComponent.headers) : Object.create(null);
+    if (mailtoComponent.subject)
+      headers.subject = mailtoComponent.subject;
+    if (mailtoComponent.body)
+      headers.body = mailtoComponent.body;
+    mailtoComponent.headers = headers;
+    let query = "";
+    let count = 0;
+    for (const name in headers) {
+      if (count++ !== 0)
+        query += "&";
+      query += encodeWithAllow(name, HFNAME) + "=" + encodeWithAllow(String(headers[name]), HFNAME);
+    }
+    if (count !== 0) {
+      mailtoComponent.query = query;
+    } else {
+      mailtoComponent.headers = undefined;
+    }
+    return mailtoComponent;
+  }
+  var mailto = {
+    scheme: "mailto",
+    parse: mailtoParse,
+    serialize: mailtoSerialize,
+    domainHost: false,
+    unicodeSupport: true,
+    skipNormalize: true,
+    absolutePath: true
+  };
   var SCHEMES = {
     http,
     https,
     ws,
     wss,
     urn,
-    "urn:uuid": urnuuid
+    "urn:uuid": urnuuid,
+    mailto
   };
   Object.setPrototypeOf(SCHEMES, null);
   function getSchemeHandler(scheme) {
@@ -41501,8 +41856,17 @@ var require_schemes = __commonJS(function(exports, module) {
 
 // node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS(function(exports, module) {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, normalizeQueryFragmentEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils4();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils4();
   var { SCHEMES, getSchemeHandler } = require_schemes();
+  var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+  var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+  function decodeValidScheme(scheme) {
+    const decodedScheme = unescape(String(scheme));
+    if (!VALID_SCHEME.test(decodedScheme)) {
+      throw new TypeError(MALFORMED_SCHEME_ERROR);
+    }
+    return decodedScheme;
+  }
   function normalize(uri, options) {
     if (typeof uri === "string") {
       uri = normalizeString(uri, options);
@@ -41513,12 +41877,34 @@ var require_fast_uri = __commonJS(function(exports, module) {
   }
   function resolve(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-    const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-    if (baseMalformed || relativeMalformed) {
+    const {
+      parsed: baseParsed,
+      malformedAuthorityOrPort: baseMalformed,
+      malformedPercentEncoding: baseMalformedPercentEncoding,
+      malformedSchemeSpecific: baseMalformedSchemeSpecific,
+      malformedHost: baseMalformedHost,
+      malformedScheme: baseMalformedScheme
+    } = parseWithStatus(baseURI, schemelessOptions);
+    const {
+      parsed: relativeParsed,
+      malformedAuthorityOrPort: relativeMalformed,
+      malformedPercentEncoding: relativeMalformedPercentEncoding,
+      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+      malformedHost: relativeMalformedHost,
+      malformedScheme: relativeMalformedScheme
+    } = parseWithStatus(relativeURI, schemelessOptions);
+    if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
       throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
     }
     const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+    const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+    const resolvedHost = resolved.host;
+    const resolvedHostIsIP = resolvedHost !== undefined && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+    canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+    const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+    if (resolved.error && !encodedASCIIHost) {
+      throw new Error(resolved.error);
+    }
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
@@ -41578,7 +41964,7 @@ var require_fast_uri = __commonJS(function(exports, module) {
   function equal(uriA, uriB, options) {
     const normalizedA = normalizeComparableURI(uriA, options);
     const normalizedB = normalizeComparableURI(uriB, options);
-    return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+    return normalizedA !== undefined && normalizedB !== undefined && normalizedA === normalizedB;
   }
   function serialize(cmpts, opts) {
     const component = {
@@ -41595,24 +41981,31 @@ var require_fast_uri = __commonJS(function(exports, module) {
       reference: cmpts.reference,
       resourceName: cmpts.resourceName,
       secure: cmpts.secure,
+      to: cmpts.to,
+      subject: cmpts.subject,
+      body: cmpts.body,
+      headers: cmpts.headers,
       error: ""
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
+    if (component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
+    }
     const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
     if (schemeHandler && schemeHandler.serialize)
       schemeHandler.serialize(component, options);
+    const hasAuthority = component.userinfo !== undefined || component.host !== undefined || component.port !== undefined;
+    const pathNoScheme = !options.skipEscape && component.scheme === undefined && !hasAuthority;
     if (component.path !== undefined) {
       if (!options.skipEscape) {
-        component.path = escapePreservingEscapes(component.path);
-        if (component.scheme !== undefined) {
-          component.path = component.path.split("%3A").join(":");
-        }
+        component.path = serializePathEncoding(component.path, pathNoScheme);
       } else {
         component.path = normalizePercentEncoding(component.path);
       }
     }
     if (options.reference !== "suffix" && component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
       uriTokens.push(component.scheme, ":");
     }
     const authority = recomposeAuthority(component);
@@ -41630,16 +42023,19 @@ var require_fast_uri = __commonJS(function(exports, module) {
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
+      if (pathNoScheme) {
+        s = serializePathEncoding(s, true);
+      }
       if (authority === undefined && s[0] === "/" && s[1] === "/") {
         s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
     if (component.query !== undefined) {
-      uriTokens.push("?", component.query);
+      uriTokens.push("?", encodeQuery(component.query));
     }
     if (component.fragment !== undefined) {
-      uriTokens.push("#", component.fragment);
+      uriTokens.push("#", encodeFragment(component.fragment));
     }
     return uriTokens.join("");
   }
@@ -41655,6 +42051,33 @@ var require_fast_uri = __commonJS(function(exports, module) {
     }
     return;
   }
+  function hasMalformedPercentEncoding(component) {
+    if (component === undefined)
+      return false;
+    let percent = component.indexOf("%");
+    while (percent !== -1) {
+      if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+        return true;
+      }
+      percent = component.indexOf("%", percent + 3);
+    }
+    return false;
+  }
+  function hasMalformedComponentPercentEncoding(matches) {
+    const host = matches[4];
+    return hasMalformedPercentEncoding(matches[3]) || host !== undefined && !(host[0] === "[" && host[host.length - 1] === "]") && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+  }
+  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && parsed.host[0] !== "[" && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+      try {
+        parsed.host = new URL("http://" + parsed.host).hostname;
+      } catch (e) {
+        parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+        return true;
+      }
+    }
+    return false;
+  }
   function parseWithStatus(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
@@ -41667,6 +42090,11 @@ var require_fast_uri = __commonJS(function(exports, module) {
       fragment: undefined
     };
     let malformedAuthorityOrPort = false;
+    let malformedPercentEncoding = false;
+    let malformedSchemeSpecific = false;
+    let malformedHost = false;
+    let malformedIPLiteral = false;
+    let malformedScheme = false;
     let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
@@ -41696,13 +42124,26 @@ var require_fast_uri = __commonJS(function(exports, module) {
     }
     const matches = uri.match(URI_PARSE);
     if (matches) {
-      parsed.scheme = matches[1] === undefined ? undefined : matches[1].toLowerCase();
+      parsed.scheme = matches[1];
       parsed.userinfo = matches[3];
       parsed.host = matches[4];
       parsed.port = parseInt(matches[5], 10);
       parsed.path = matches[6] || "";
       parsed.query = matches[7];
       parsed.fragment = matches[8];
+      if (parsed.scheme !== undefined) {
+        const decodedScheme = unescape(parsed.scheme);
+        if (VALID_SCHEME.test(decodedScheme)) {
+          parsed.scheme = decodedScheme.toLowerCase();
+        } else {
+          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+          malformedScheme = true;
+        }
+      }
+      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+      if (malformedPercentEncoding) {
+        parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+      }
       if (isNaN(parsed.port)) {
         parsed.port = matches[5];
       }
@@ -41714,9 +42155,15 @@ var require_fast_uri = __commonJS(function(exports, module) {
       if (parsed.host) {
         const ipv4result = isIPv4(parsed.host);
         if (ipv4result === false) {
+          const bracketedIPLiteral = parsed.host[0] === "[" && parsed.host[parsed.host.length - 1] === "]";
           const ipv6result = normalizeIPv6(parsed.host);
-          parsed.host = ipv6result.host.toLowerCase();
-          isIP = ipv6result.isIPV6;
+          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+          malformedIPLiteral = bracketedIPLiteral && ipv6result.error === true;
+          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+          if (malformedIPLiteral) {
+            parsed.error = parsed.error || "URI host is malformed.";
+            malformedAuthorityOrPort = true;
+          }
         } else {
           isIP = true;
         }
@@ -41734,22 +42181,12 @@ var require_fast_uri = __commonJS(function(exports, module) {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
       const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-          try {
-            parsed.host = new URL("http://" + parsed.host).hostname;
-          } catch (e) {
-            parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-          }
-        }
-      }
+      malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
         if (uri.indexOf("%") !== -1) {
-          if (parsed.scheme !== undefined) {
-            parsed.scheme = unescape(parsed.scheme);
-          }
-          if (parsed.host !== undefined) {
-            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+          if (parsed.host !== undefined && !malformedIPLiteral) {
+            const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+            parsed.host = reescapeHostDelimiters(host, isIP);
           }
         }
         if (parsed.path) {
@@ -41764,11 +42201,14 @@ var require_fast_uri = __commonJS(function(exports, module) {
       }
       if (schemeHandler && schemeHandler.parse) {
         schemeHandler.parse(parsed, options);
+        if (schemeHandler === SCHEMES.urn && parsed.nid === undefined) {
+          malformedSchemeSpecific = true;
+        }
       }
     } else {
       parsed.error = parsed.error || "URI can not be parsed.";
     }
-    return { parsed, malformedAuthorityOrPort };
+    return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
   }
   function parse6(uri, opts) {
     return parseWithStatus(uri, opts).parsed;
@@ -41777,20 +42217,28 @@ var require_fast_uri = __commonJS(function(exports, module) {
     return normalizeStringWithStatus(uri, opts).normalized;
   }
   function normalizeStringWithStatus(uri, opts) {
-    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
     return {
-      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-      malformedAuthorityOrPort
+      normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort,
+      malformedPercentEncoding,
+      malformedSchemeSpecific,
+      malformedHost,
+      malformedScheme
     };
   }
   function normalizeComparableURI(uri, opts) {
-    if (typeof uri === "string") {
-      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-      return malformedAuthorityOrPort ? undefined : normalized;
+    if (typeof uri !== "string" && typeof uri !== "object") {
+      return;
     }
-    if (typeof uri === "object") {
-      return serialize(uri, opts);
+    let value;
+    try {
+      value = typeof uri === "string" ? uri : serialize(uri, opts);
+    } catch {
+      return;
     }
+    const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+    return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? undefined : normalized;
   }
   var fastUri = {
     SCHEMES,
@@ -51498,9 +51946,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.1.0",
-    sdkVersion: "0.0.41",
+    sdkVersion: "0.0.43",
     genVersion: "2.915.1",
-    userAgent: "speakeasy-sdk/mcp-typescript 0.0.41 2.915.1 0.1.0 @dalmia/calibrate-mcp"
+    userAgent: "speakeasy-sdk/mcp-typescript 0.0.43 2.915.1 0.1.0 @dalmia/calibrate-mcp"
   };
 });
 
@@ -53689,8 +54137,9 @@ var init_routersevaluatorsevaluatorresponse = __esm(() => {
     "stt",
     "llm",
     "llm-general",
-    "conversation"
-  ]).describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n");
+    "conversation",
+    "tool-call"
+  ]).describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n- `tool-call`: whether the agent called the right tool, labelled by a person\n");
   RoutersEvaluatorsEvaluatorResponseDataType$zodSchema = _enum([
     "text",
     "audio"
@@ -53703,8 +54152,9 @@ var init_routersevaluatorsevaluatorresponse = __esm(() => {
     created_at: string2().describe("When the evaluator was created (ISO 8601 UTC)"),
     data_type: RoutersEvaluatorsEvaluatorResponseDataType$zodSchema.describe("The modality the judge reads:\n\n- `text`\n- `audio`\n"),
     description: string2().nullable().optional().describe("What the evaluator checks"),
-    evaluator_type: RoutersEvaluatorsEvaluatorResponseEvaluatorType$zodSchema.describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n"),
+    evaluator_type: RoutersEvaluatorsEvaluatorResponseEvaluatorType$zodSchema.describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n- `tool-call`: whether the agent called the right tool, labelled by a person\n"),
     is_default: boolean2().describe("True when the evaluator is a built-in default or your workspace's editable copy of one. False for an evaluator you created yourself"),
+    is_protected: boolean2().describe("True when the evaluator is locked. A locked evaluator cannot be deleted, and only its name, description and rubric can change"),
     live_version: EvaluatorLiveVersionSummary$zodSchema.nullable().optional().describe("The version that is currently live"),
     live_version_id: string2().nullable().optional().describe("ID of the version that is currently live"),
     name: string2().describe("Evaluator name"),
@@ -56523,7 +56973,7 @@ var init_annotationtaskresponse = __esm(() => {
     evaluators: array(record(string2(), any())).optional().describe("The evaluators linked to this task, in display order. Fetching one task by ID enriches each with its live version's rubric. Listing tasks returns lightweight metadata (uuid, name, type, position) only"),
     has_agreement: boolean2().default(false).describe("Whether the task has at least one comparable human-vs-human or human-vs-evaluator pair, computed over all time"),
     item_count: int().nullable().optional().describe("Number of items in the task"),
-    items: array(record(string2(), any())).optional().describe("The task's items, each with its agreement stats. You get these when you fetch one task by ID, not when you list tasks"),
+    items: array(record(string2(), any())).optional().describe("The task's items, each with its agreement stats and an `is_tool_call` flag marking the rows a person labels on the tool call rather than a text reply. You get these when you fetch one task by ID, not when you list tasks"),
     jobs: array(record(string2(), any())).optional().describe("The task's labelling jobs. You get these when you fetch one task by ID, not when you list tasks"),
     name: string2().describe("Name of the task"),
     type: AnnotationTaskResponseType$zodSchema.describe("Task type. Determines the shape of each item's payload.\n- `stt`: judge a transcript on its own\n- `llm`: judge one response with its conversation history\n- `llm-general`: judge a standalone `input -> output` pair\n- `conversation`: judge a full conversation"),
@@ -58211,8 +58661,9 @@ var init_evaluatorcreate = __esm(() => {
     "stt",
     "llm",
     "llm-general",
-    "conversation"
-  ]).describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n");
+    "conversation",
+    "tool-call"
+  ]).describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n- `tool-call`: whether the agent called the right tool, labelled by a person\n");
   EvaluatorCreateDataType$zodSchema = _enum([
     "text",
     "audio"
@@ -58224,7 +58675,7 @@ var init_evaluatorcreate = __esm(() => {
   EvaluatorCreate$zodSchema = object({
     data_type: EvaluatorCreateDataType$zodSchema.default("text").describe("The modality the judge reads:\n\n- `text`\n- `audio`\n"),
     description: string2().nullable().optional().describe("Description. Omit to leave blank"),
-    evaluator_type: EvaluatorCreateEvaluatorType$zodSchema.default("llm").describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n"),
+    evaluator_type: EvaluatorCreateEvaluatorType$zodSchema.default("llm").describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n- `tool-call`: whether the agent called the right tool, labelled by a person\n"),
     name: string2().describe("Evaluator name, unique within your workspace"),
     output_type: EvaluatorCreateOutputType$zodSchema.default("binary").describe("How the evaluator scores:\n\n- `binary`: pass or fail\n- `rating`: a numeric score, using the scale in `output_config`\n"),
     version: EvaluatorVersionCreate$zodSchema.describe("One version of an evaluator: its judge prompt, model, variables, and rubric.")
@@ -58558,8 +59009,9 @@ var init_evaluatordetailresponsecompact = __esm(() => {
     "stt",
     "llm",
     "llm-general",
-    "conversation"
-  ]).describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n");
+    "conversation",
+    "tool-call"
+  ]).describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n- `tool-call`: whether the agent called the right tool, labelled by a person\n");
   EvaluatorDetailResponseCompactDataType$zodSchema = _enum([
     "text",
     "audio"
@@ -58572,8 +59024,9 @@ var init_evaluatordetailresponsecompact = __esm(() => {
     created_at: string2().describe("When the evaluator was created (ISO 8601 UTC)"),
     data_type: EvaluatorDetailResponseCompactDataType$zodSchema.describe("The modality the judge reads:\n\n- `text`\n- `audio`\n"),
     description: string2().nullable().optional().describe("What the evaluator checks"),
-    evaluator_type: EvaluatorDetailResponseCompactEvaluatorType$zodSchema.describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n"),
+    evaluator_type: EvaluatorDetailResponseCompactEvaluatorType$zodSchema.describe("What the evaluator judges:\n\n- `tts`: TTS audio\n- `stt`: one transcript\n- `llm`: a reply with its conversation history\n- `llm-general`: a standalone input and output pair\n- `conversation`: a full conversation\n- `tool-call`: whether the agent called the right tool, labelled by a person\n"),
     is_default: boolean2().describe("True when the evaluator is a built-in default or your workspace's editable copy of one. False for an evaluator you created yourself"),
+    is_protected: boolean2().describe("True when the evaluator is locked. A locked evaluator cannot be deleted, and only its name, description and rubric can change"),
     live_version_id: string2().nullable().optional().describe("ID of the version that is currently live"),
     name: string2().describe("Evaluator name"),
     output_type: EvaluatorDetailResponseCompactOutputType$zodSchema.describe("How the evaluator scores:\n\n- `binary`: pass or fail\n- `rating`: a numeric score, using the scale in `output_config`\n"),
@@ -58734,7 +59187,8 @@ var init_listevaluatorsevaluatorsgetop = __esm(() => {
     "stt",
     "llm",
     "llm-general",
-    "conversation"
+    "conversation",
+    "tool-call"
   ]).describe("Filter by what the evaluator judges. Omit for all types");
   ListEvaluatorsEvaluatorsGetDataType$zodSchema = _enum([
     "text",
@@ -59930,7 +60384,7 @@ hits its trace limit.
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "CalibrateMcp",
-    version: "0.0.41"
+    version: "0.0.43"
   });
   const getClient = deps.getSDK || (() => new CalibrateMcpCore({
     security: deps.security,
@@ -61196,7 +61650,7 @@ http_headers = { "api-key-auth" = "YOUR_API_KEY_AUTH" }`;
         <h1>Instructions</h1>
         <p>One-click installation for Claude Desktop users</p>
         <div class="instruction-item">
-          <a href="https://github.com/dalmia/calibrate-mcp/releases/download/v0.0.41/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
+          <a href="https://github.com/dalmia/calibrate-mcp/releases/download/v0.0.43/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
             \uD83D\uDCE5 Download MCP Bundle
           </a>
         </div>
@@ -64083,7 +64537,7 @@ var routes = buildRouteMap({
 var app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.0.41"
+    currentVersion: "0.0.43"
   }
 });
 run(app, process4.argv.slice(2), buildContext(process4));
@@ -64091,5 +64545,5 @@ export {
   app
 };
 
-//# debugId=D022F7D0B95E1DD664756E2164756E21
+//# debugId=AF946BF2D9C57E1564756E2164756E21
 //# sourceMappingURL=mcp-server.js.map