@modelcontextprotocol/inspector 1.0.3 → 1.0.4

package/cli/build/index.js

@@ -6,6 +6,7 @@ import { callTool, connect, disconnect, getPrompt, listPrompts, listResources, l
 import { handleError } from "./error-handler.js";
 import { createTransport } from "./transport.js";
 import { awaitableLog } from "./utils/awaitable-log.js";
+import { RegexFreeJsonSchemaValidator } from "./utils/regexFreeSchemaValidator.js";
 function createTransportOptions(target, transport, headers) {
     if (target.length === 0) {
         throw new Error("Target is required. Specify a URL or a command to execute.");
@@ -65,7 +66,12 @@ async function callMethod(args) {
     const [, name = packageJson.name] = packageJson.name.split("/");
     const version = packageJson.version;
     const clientIdentity = { name, version };
-    const client = new Client(clientIdentity);
+    // Tool output schemas come from the server; the SDK validates results
+    // against them, so give it a provider that never runs their regexes on the
+    // native backtracking RegExp engine (skipped patterns are noted on stderr).
+    const client = new Client(clientIdentity, {
+        jsonSchemaValidator: new RegexFreeJsonSchemaValidator((note) => console.error(`Warning: ${note}`)),
+    });
     try {
         await connect(client, transport);
         let result;

package/cli/build/utils/regexFreeSchemaValidator.js

@@ -0,0 +1,55 @@
+/**
+ * The JSON Schema validator provider the CLI hands the SDK `Client`, which
+ * uses it to validate every `tools/call` result's `structuredContent` against
+ * the tool's server-supplied `outputSchema`.
+ *
+ * It wraps the SDK's own default provider (`AjvJsonSchemaValidator`) and
+ * changes one thing: the schema is passed through {@link stripSchemaPatterns}
+ * first, so no server-supplied `pattern` / `patternProperties` regex is ever
+ * run on the native backtracking `RegExp` engine, where a pattern such as
+ * `^(a+)+$` and a near-match value would hang the CLI. Every other keyword is
+ * still validated by the SDK's validator, unchanged.
+ *
+ * A schema that declares an identifier is not validated at all (see
+ * stripSchemaPatterns); every result passes and the note says so.
+ *
+ * Skipped regexes are not silent: a failing result's message ends with the
+ * "not evaluated" note, and a passing one reports it through `onNote` (the
+ * CLI writes it to stderr, keeping stdout's JSON clean).
+ */
+import { AjvJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/ajv";
+import { schemaNote, stripSchemaPatterns } from "./stripSchemaPatterns.js";
+export class RegexFreeJsonSchemaValidator {
+    inner;
+    onNote;
+    constructor(onNote, inner = new AjvJsonSchemaValidator()) {
+        this.onNote = onNote;
+        this.inner = inner;
+    }
+    getValidator(schema) {
+        const result = stripSchemaPatterns(schema);
+        const note = schemaNote(result);
+        if (!result.validate) {
+            // Not validated at all (the schema declares an identifier): every
+            // result passes, and the note says the schema was not checked.
+            return (input) => {
+                this.onNote(note);
+                // Unchecked by design; `T` is what the caller asked the schema for.
+                return { valid: true, data: input, errorMessage: undefined };
+            };
+        }
+        // `stripSchemaPatterns` returns a structural copy of a JsonSchemaType
+        // with keywords removed, which is still a JsonSchemaType.
+        const validate = this.inner.getValidator(result.schema);
+        if (note === undefined)
+            return validate;
+        return (input) => {
+            const checked = validate(input);
+            if (checked.valid) {
+                this.onNote(note);
+                return checked;
+            }
+            return { ...checked, errorMessage: `${checked.errorMessage} (${note})` };
+        };
+    }
+}

package/cli/build/utils/stripSchemaPatterns.js

@@ -0,0 +1,467 @@
+/**
+ * Prepare a server-supplied JSON Schema for validation without evaluating any
+ * of its regular expressions.
+ *
+ * `pattern` and `patternProperties` regexes come from the server, and Ajv
+ * runs them on the native backtracking `RegExp` engine: a pattern such as
+ * `^(a+)+$` checked against a near-match string takes exponential time and
+ * freezes the thread doing the validation. Rather than evaluate them, this
+ * returns a COPY of the schema with every regex removed, plus counts, so the
+ * caller can say visibly what was not checked. The original schema object is
+ * never mutated (the UI displays it).
+ *
+ * INVARIANT: the output schema accepts every value the input schema accepts
+ * — it may be less strict, and says so, but never stricter — or validation
+ * is skipped altogether (`validate: false`) and the note says so. Every rule
+ * below exists to keep that; when one cannot be kept simply, give up rather
+ * than add cleverness.
+ *
+ * 0. A schema that declares an identifier anywhere in a schema position
+ *    (`$id`, draft-04 `id`, `$anchor`, `$dynamicAnchor`, `$recursiveAnchor`)
+ *    is not validated at all. Identifiers change how references resolve, and
+ *    moving a subschema (rule 2) would move its identifier scope with it.
+ *
+ * 1. Only schema positions are rewritten. The walk follows the keywords that
+ *    hold subschemas, so a property NAMED `pattern`, or a `pattern` key inside
+ *    a `const` / `enum` / `default` value, is data and is left alone.
+ *
+ * 2. Every `$ref` is re-pointed at a sanitized copy, or removed. Ajv resolves
+ *    a JSON pointer to ANY location in the document (`#/default`, say), and
+ *    compiles whatever it finds there as a schema — so a reference to a place
+ *    the walk did not visit would hand Ajv an unsanitized regex. A `$ref` is
+ *    kept only when it is a local `#/...` pointer to a schema position the
+ *    walk visited; it is then rewritten to that position's place in the
+ *    output. Any other `$ref` takes its whole node with it: the node becomes
+ *    `{}`, siblings included, since Ajv 6 ignores a `$ref`'s siblings and
+ *    activating them could reject what the reference accepted (under Ajv 8
+ *    dropping them only loosens). Its subschemas are kept resolvable as in
+ *    rule 2. A `$dynamicRef` / `$recursiveRef` is removed on its own (Ajv 6
+ *    does not know it, so its siblings were already active). Each counts as
+ *    skipped.
+ *
+ * 3. Removing a constraint loosens the schema that holds it, and loosening is
+ *    only safe in a positive position. Under `not`, inside a `oneOf` branch
+ *    (where a looser branch can make two branches match), in an `if`
+ *    condition (which decides whether `then` or `else` applies), in
+ *    `contains` (bounded by `maxContains`) and beneath `unevaluated*` (whose
+ *    verdict depends on what sibling keywords evaluated), a looser subschema
+ *    can turn a pass into a failure. So a subschema that lost anything —
+ *    directly, or through a child or a `$ref` target — is "tainted", and a
+ *    keyword of that kind whose subschema is tainted is removed whole and
+ *    counted as skipped. Independent sibling constraints are kept. `allOf`,
+ *    `anyOf`, `properties`, `items`, `then` / `else` and the rest only ever
+ *    loosen, so they stay.
+ *
+ * `patternProperties` with at least one key is removed, and so is the
+ * `additionalProperties` beside it: without the regexes, which keys are
+ * "additional" is unknowable, and `additionalProperties: false` would reject
+ * keys the server declared as allowed. An EMPTY `patternProperties` holds no
+ * regex, so it and its `additionalProperties` are kept as they are.
+ *
+ * Nothing that a `$ref` could target is deleted outright: a removed subschema
+ * is moved, sanitized, into the root's `definitions` under a generated name
+ * (where nothing applies it), and references into it are rewritten there. So
+ * the transformed schema always still compiles.
+ */
+/** Keywords whose value is a single subschema. */
+const SCHEMA_KEYWORDS = [
+    "additionalProperties",
+    "additionalItems",
+    "contains",
+    "propertyNames",
+    "if",
+    "then",
+    "else",
+    "not",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+];
+/** Keywords whose value is an array of subschemas. */
+const SCHEMA_ARRAY_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems"];
+/** Keywords whose value maps names to subschemas. */
+const SCHEMA_MAP_KEYWORDS = [
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas",
+    "dependencies",
+];
+/** Prefix of the `definitions` entries removed subschemas are moved to. */
+const HOLDING_PREFIX = "__inspector_unevaluated_";
+/** Keywords that declare an identifier; any one means "do not validate". */
+const IDENTIFIER_KEYWORDS = [
+    "$id",
+    "id",
+    "$anchor",
+    "$dynamicAnchor",
+    "$recursiveAnchor",
+];
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSchema(value) {
+    return isObject(value) || typeof value === "boolean";
+}
+/** A map key for a `Rel`. Keywords never contain NUL, so this is unique. */
+const relKey = (rel) => rel.length === 1 ? rel[0] : `${rel[0]}\u0000${rel[1]}`;
+/** Every subschema of `node`, as relative locations. */
+function childRels(node) {
+    const rels = [];
+    for (const key of SCHEMA_KEYWORDS) {
+        if (isSchema(node[key]))
+            rels.push([key]);
+    }
+    for (const key of SCHEMA_ARRAY_KEYWORDS) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+            value.forEach((sub, i) => {
+                if (isSchema(sub))
+                    rels.push([key, String(i)]);
+            });
+        }
+    }
+    for (const key of SCHEMA_MAP_KEYWORDS) {
+        const value = node[key];
+        if (isObject(value)) {
+            for (const [name, sub] of Object.entries(value)) {
+                // `dependencies` may map to a string array (property dependency).
+                if (isSchema(sub))
+                    rels.push([key, name]);
+            }
+        }
+    }
+    // `items` is either one subschema or (draft-07 tuple form) an array.
+    if (Array.isArray(node.items)) {
+        node.items.forEach((sub, i) => {
+            if (isSchema(sub))
+                rels.push(["items", String(i)]);
+        });
+    }
+    else if (isSchema(node.items)) {
+        rels.push(["items"]);
+    }
+    return rels;
+}
+function getAt(node, rel) {
+    const value = node[rel[0]];
+    return rel.length === 1 ? value : value[rel[1]];
+}
+/**
+ * Parse a `$ref` the way Ajv resolves a local JSON pointer: split on `/`,
+ * then URI-decode and JSON-pointer-unescape each segment. `null` for any
+ * reference that is not a local `#` / `#/...` pointer.
+ */
+function parseLocalRef(ref) {
+    if (ref === "#")
+        return [];
+    if (!ref.startsWith("#/"))
+        return null;
+    // An encoded `/` is ambiguous: Ajv 6 splits before decoding (one segment,
+    // `x/y`), while Ajv 8 decodes first (two segments, `x` then `y`), so the
+    // two can resolve different schemas. Give it up rather than guess. A NUL
+    // could collide with the internal child keys, so it is given up too.
+    if (/%2f|%00/i.test(ref) || ref.includes("\u0000"))
+        return null;
+    try {
+        return ref
+            .slice(2)
+            .split("/")
+            .map((part) => decodeURIComponent(part).replace(/~1/g, "/").replace(/~0/g, "~"));
+    }
+    catch {
+        return null; // malformed percent-encoding
+    }
+}
+const formatSegment = (part) => "/" + encodeURIComponent(part.replace(/~/g, "~0").replace(/\//g, "~1"));
+/** References whose target depends on the dynamic scope; always removed. */
+const DYNAMIC_REF_KEYWORDS = ["$dynamicRef", "$recursiveRef"];
+/**
+ * Every pass below is linear in the size of the schema: each position is
+ * visited once, each container is copied once, taint spreads along reversed
+ * edges with a work list, and positions are numbers rather than paths (a path
+ * per position would cost O(depth) each). Only the pointers actually written
+ * into rewritten `$ref`s are built as strings, memoized per position.
+ */
+export function stripSchemaPatterns(schema) {
+    // Pass 1: number every schema position, and record what each depends on.
+    const positions = [];
+    const rawRefs = [];
+    let hasIdentifier = false;
+    const analyze = (node, parent) => {
+        const id = positions.length;
+        const position = {
+            node,
+            parent,
+            children: new Map(),
+            direct: false,
+            dynamic: false,
+        };
+        positions.push(position);
+        if (!isObject(node))
+            return id; // `true` / `false` schemas, or junk
+        if (IDENTIFIER_KEYWORDS.some((key) => key in node))
+            hasIdentifier = true;
+        if (typeof node.pattern === "string")
+            position.direct = true;
+        if (isObject(node.patternProperties) &&
+            Object.keys(node.patternProperties).length > 0) {
+            position.direct = true;
+        }
+        if (typeof node.$ref === "string")
+            rawRefs.push([id, node.$ref]);
+        if (DYNAMIC_REF_KEYWORDS.some((key) => key in node)) {
+            position.dynamic = true;
+        }
+        for (const rel of childRels(node)) {
+            position.children.set(relKey(rel), analyze(getAt(node, rel), id));
+        }
+        return id;
+    };
+    analyze(schema, -1);
+    /** The position a pointer names, if it names one. */
+    const resolve = (segments) => {
+        let current = 0;
+        for (let i = 0; i < segments.length;) {
+            const { children } = positions[current];
+            const single = children.get(segments[i]);
+            if (single !== undefined) {
+                current = single;
+                i += 1;
+                continue;
+            }
+            if (i + 1 >= segments.length)
+                return null;
+            const pair = children.get(`${segments[i]}\u0000${segments[i + 1]}`);
+            if (pair === undefined)
+                return null;
+            current = pair;
+            i += 2;
+        }
+        return current;
+    };
+    const referrers = new Map();
+    for (const [id, ref] of rawRefs) {
+        const segments = parseLocalRef(ref);
+        const target = segments === null ? null : resolve(segments);
+        positions[id].ref = target;
+        if (target !== null) {
+            const list = referrers.get(target) ?? [];
+            list.push(id);
+            referrers.set(target, list);
+        }
+    }
+    // Pass 2: a position is tainted if it, a subschema, or a `$ref` target
+    // lost anything. Spread from the seeds along reversed edges (to the parent
+    // and to every referrer); each position enters the work list at most once.
+    const tainted = new Uint8Array(positions.length);
+    const work = [];
+    const taint = (id) => {
+        if (id < 0 || tainted[id])
+            return;
+        tainted[id] = 1;
+        work.push(id);
+    };
+    positions.forEach((position, id) => {
+        if (position.direct || position.dynamic || position.ref === null) {
+            taint(id);
+        }
+    });
+    while (work.length > 0) {
+        const id = work.pop();
+        taint(positions[id].parent);
+        for (const referrer of referrers.get(id) ?? [])
+            taint(referrer);
+    }
+    // Pass 3: emit the sanitized copy, recording where each position landed
+    // (its output parent and location) so references can be rewritten to it.
+    let stripped = 0;
+    let skipped = 0;
+    const outParent = new Int32Array(positions.length).fill(-2); // -2: unset
+    const outRel = new Array(positions.length);
+    const refSites = [];
+    const holding = [];
+    const root = isObject(schema) ? schema : undefined;
+    const takenNames = new Set(isObject(root?.definitions) ? Object.keys(root.definitions) : []);
+    let nextName = 0;
+    const emit = (id) => {
+        const { node, children } = positions[id];
+        if (!isObject(node))
+            return node;
+        const childOf = (rel) => children.get(relKey(rel));
+        /** Move a subschema somewhere nothing applies it, keeping it resolvable. */
+        const relocate = (rel) => holding.push(childOf(rel));
+        if (positions[id].ref === null) {
+            // A `$ref` that cannot be kept takes its whole node (see rule 2).
+            childRels(node).forEach(relocate);
+            skipped++;
+            return {};
+        }
+        const copy = { ...node };
+        const isTainted = (rel) => tainted[childOf(rel)] === 1;
+        if (typeof copy.pattern === "string") {
+            delete copy.pattern;
+            stripped++;
+        }
+        if (isObject(copy.patternProperties) &&
+            Object.keys(copy.patternProperties).length > 0) {
+            for (const name of Object.keys(copy.patternProperties)) {
+                if (isSchema(copy.patternProperties[name])) {
+                    relocate(["patternProperties", name]);
+                }
+                stripped++;
+            }
+            delete copy.patternProperties;
+            // See the header: without the regexes, which keys are "additional" is
+            // unknowable, so this constraint is skipped too.
+            if ("additionalProperties" in copy) {
+                if (isSchema(copy.additionalProperties)) {
+                    relocate(["additionalProperties"]);
+                }
+                delete copy.additionalProperties;
+                skipped++;
+            }
+        }
+        // Keywords where a looser subschema can produce a false failure.
+        const dropIfTainted = (keyword, alsoDrop = []) => {
+            if (!(keyword in copy))
+                return;
+            const rels = childRels({ [keyword]: copy[keyword] });
+            if (!rels.some(isTainted))
+                return;
+            rels.forEach(relocate);
+            delete copy[keyword];
+            for (const extra of alsoDrop)
+                delete copy[extra];
+            skipped++;
+        };
+        dropIfTainted("not");
+        dropIfTainted("oneOf");
+        if (isSchema(copy.if) && isTainted(["if"])) {
+            for (const keyword of ["if", "then", "else"]) {
+                if (isSchema(copy[keyword]))
+                    relocate([keyword]);
+                delete copy[keyword];
+            }
+            skipped++;
+        }
+        dropIfTainted("contains", ["minContains", "maxContains"]);
+        if (tainted[id]) {
+            // What counts as "evaluated" depends on the sibling keywords, which
+            // lost something, so these can no longer be judged.
+            for (const keyword of ["unevaluatedProperties", "unevaluatedItems"]) {
+                if (keyword in copy) {
+                    if (isSchema(copy[keyword]))
+                        relocate([keyword]);
+                    delete copy[keyword];
+                    skipped++;
+                }
+            }
+        }
+        for (const keyword of DYNAMIC_REF_KEYWORDS) {
+            if (keyword in copy) {
+                delete copy[keyword];
+                skipped++;
+            }
+        }
+        const target = positions[id].ref;
+        if (typeof copy.$ref === "string" && typeof target === "number") {
+            refSites.push({ node: copy, target });
+        }
+        // Recurse into whatever subschemas are still applied here. Each array or
+        // map is copied once, then filled in, so the original is never mutated.
+        const cloned = new Set();
+        for (const rel of childRels(copy)) {
+            const child = childOf(rel);
+            outParent[child] = id;
+            outRel[child] = rel;
+            const sub = emit(child);
+            if (rel.length === 1) {
+                copy[rel[0]] = sub;
+                continue;
+            }
+            const [keyword, name] = rel;
+            if (!cloned.has(keyword)) {
+                cloned.add(keyword);
+                const container = copy[keyword];
+                copy[keyword] = Array.isArray(container)
+                    ? [...container]
+                    : { ...container };
+            }
+            copy[keyword][name] = sub;
+        }
+        return copy;
+    };
+    outParent[0] = -1;
+    outRel[0] = [];
+    const output = emit(0);
+    if (isObject(output) && holding.length > 0) {
+        const definitions = isObject(output.definitions)
+            ? { ...output.definitions }
+            : {};
+        // A held subschema may itself hold more; iterating the array as it
+        // grows picks those up.
+        for (const id of holding) {
+            let name;
+            do {
+                name = `${HOLDING_PREFIX}${nextName++}`;
+            } while (takenNames.has(name));
+            takenNames.add(name);
+            outParent[id] = 0;
+            outRel[id] = ["definitions", name];
+            definitions[name] = emit(id);
+        }
+        output.definitions = definitions;
+    }
+    // Build the pointer for each referenced position once, from its parent's.
+    const pointers = new Map();
+    const pointerOf = (id) => {
+        if (outParent[id] === -2)
+            return undefined; // never emitted
+        if (id === 0)
+            return "#";
+        const memo = pointers.get(id);
+        if (memo !== undefined)
+            return memo;
+        // Walk up iteratively to the nearest memoized ancestor (no recursion, so
+        // a deep schema cannot overflow the stack here).
+        const chain = [];
+        let current = id;
+        while (current !== 0 && !pointers.has(current)) {
+            chain.push(current);
+            current = outParent[current];
+        }
+        let pointer = current === 0 ? "#" : pointers.get(current);
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const link = chain[i];
+            pointer += outRel[link].map(formatSegment).join("");
+            pointers.set(link, pointer);
+        }
+        return pointer;
+    };
+    for (const site of refSites) {
+        // Every position is emitted (in place or held), so this always resolves.
+        site.node.$ref = pointerOf(site.target);
+    }
+    return { schema: output, stripped, skipped, validate: !hasIdentifier };
+}
+/** The user-facing note for a result, or `undefined` if nothing was lost. */
+export function schemaNote(result) {
+    if (!result.validate) {
+        return "this schema was not validated: it declares an $id or $anchor, which the Inspector does not resolve";
+    }
+    if (result.stripped === 0 && result.skipped === 0)
+        return undefined;
+    return patternsNotEvaluatedNote(result.stripped, result.skipped);
+}
+/** The user-facing note for a schema that had checks removed. */
+export function patternsNotEvaluatedNote(stripped, skipped = 0) {
+    const parts = [];
+    if (stripped > 0) {
+        parts.push(`${stripped} regex pattern(s) in this schema were not evaluated`);
+    }
+    if (skipped > 0) {
+        parts.push(`${skipped} check(s) in this schema were skipped because they depend on an unevaluated pattern or an unresolvable $ref`);
+    }
+    return parts.join("; ");
+}

package/client/dist/assets/{OAuthCallback-jbB02Bt3.js → OAuthCallback-Cb6VJMaq.js}

@@ -1,4 +1,4 @@
-import { u as useToast, r as reactExports, c as clearOAuthConnectionSnapshot, j as jsxRuntimeExports, p as parseOAuthCallbackParams, g as generateOAuthErrorDescription, S as SESSION_KEYS, I as InspectorOAuthClientProvider, a as auth } from "./index-C2CDzlVy.js";
+import { u as useToast, r as reactExports, c as clearOAuthConnectionSnapshot, j as jsxRuntimeExports, p as parseOAuthCallbackParams, g as generateOAuthErrorDescription, S as SESSION_KEYS, I as InspectorOAuthClientProvider, a as auth } from "./index-Bvgm3HOZ.js";
 const OAuthCallback = ({ onConnect }) => {
   const { toast } = useToast();
   const hasProcessedRef = reactExports.useRef(false);

package/client/dist/assets/{OAuthDebugCallback-VeJ8bP3s.js → OAuthDebugCallback-CgAV2c_T.js}

@@ -1,4 +1,4 @@
-import { r as reactExports, S as SESSION_KEYS, p as parseOAuthCallbackParams, j as jsxRuntimeExports, g as generateOAuthErrorDescription } from "./index-C2CDzlVy.js";
+import { r as reactExports, S as SESSION_KEYS, p as parseOAuthCallbackParams, j as jsxRuntimeExports, g as generateOAuthErrorDescription } from "./index-Bvgm3HOZ.js";
 const OAuthDebugCallback = ({ onConnect }) => {
   reactExports.useEffect(() => {
     let isProcessed = false;

package/client/dist/assets/{index-C2CDzlVy.js → index-Bvgm3HOZ.js}

@@ -12400,7 +12400,7 @@ function esc(str) {
 }
 const captureStackTrace = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => {
 };
-function isObject(data2) {
+function isObject$1(data2) {
   return typeof data2 === "object" && data2 !== null && !Array.isArray(data2);
 }
 const allowsEval = cached(() => {
@@ -12416,13 +12416,13 @@ const allowsEval = cached(() => {
   }
 });
 function isPlainObject$2(o2) {
-  if (isObject(o2) === false)
+  if (isObject$1(o2) === false)
     return false;
   const ctor = o2.constructor;
   if (ctor === void 0)
     return true;
   const prot = ctor.prototype;
-  if (isObject(prot) === false)
+  if (isObject$1(prot) === false)
     return false;
   if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
     return false;
@@ -13877,7 +13877,7 @@ const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     return (payload, ctx) => fn2(shape, payload, ctx);
   };
   let fastpass;
-  const isObject$1 = isObject;
+  const isObject2 = isObject$1;
   const jit = !globalConfig.jitless;
   const allowsEval$1 = allowsEval;
   const fastEnabled = jit && allowsEval$1.value;
@@ -13886,7 +13886,7 @@ const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject$1(input)) {
+    if (!isObject2(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -14045,7 +14045,7 @@ const $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUn
   });
   inst._zod.parse = (payload, ctx) => {
     const input = payload.value;
-    if (!isObject(input)) {
+    if (!isObject$1(input)) {
       payload.issues.push({
         code: "invalid_type",
         expected: "object",
@@ -17366,7 +17366,7 @@ object({
   token_type_hint: string().optional()
 }).strip();
 const name = "@modelcontextprotocol/inspector-client";
-const version$1 = "1.0.3";
+const version$1 = "1.0.4";
 const packageJson = {
   name,
   version: version$1
@@ -29909,15 +29909,348 @@ function requireAjv$2() {
 }
 var ajvExports$1 = requireAjv$2();
 const Ajv$1 = /* @__PURE__ */ getDefaultExportFromCjs(ajvExports$1);
+const SCHEMA_KEYWORDS = [
+  "additionalProperties",
+  "additionalItems",
+  "contains",
+  "propertyNames",
+  "if",
+  "then",
+  "else",
+  "not",
+  "unevaluatedItems",
+  "unevaluatedProperties"
+];
+const SCHEMA_ARRAY_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems"];
+const SCHEMA_MAP_KEYWORDS = [
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas",
+  "dependencies"
+];
+const HOLDING_PREFIX = "__inspector_unevaluated_";
+const IDENTIFIER_KEYWORDS = [
+  "$id",
+  "id",
+  "$anchor",
+  "$dynamicAnchor",
+  "$recursiveAnchor"
+];
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSchema(value) {
+  return isObject(value) || typeof value === "boolean";
+}
+const relKey = (rel) => rel.length === 1 ? rel[0] : `${rel[0]}\0${rel[1]}`;
+function childRels(node) {
+  const rels = [];
+  for (const key of SCHEMA_KEYWORDS) {
+    if (isSchema(node[key])) rels.push([key]);
+  }
+  for (const key of SCHEMA_ARRAY_KEYWORDS) {
+    const value = node[key];
+    if (Array.isArray(value)) {
+      value.forEach((sub, i2) => {
+        if (isSchema(sub)) rels.push([key, String(i2)]);
+      });
+    }
+  }
+  for (const key of SCHEMA_MAP_KEYWORDS) {
+    const value = node[key];
+    if (isObject(value)) {
+      for (const [name2, sub] of Object.entries(value)) {
+        if (isSchema(sub)) rels.push([key, name2]);
+      }
+    }
+  }
+  if (Array.isArray(node.items)) {
+    node.items.forEach((sub, i2) => {
+      if (isSchema(sub)) rels.push(["items", String(i2)]);
+    });
+  } else if (isSchema(node.items)) {
+    rels.push(["items"]);
+  }
+  return rels;
+}
+function getAt(node, rel) {
+  const value = node[rel[0]];
+  return rel.length === 1 ? value : value[rel[1]];
+}
+function parseLocalRef(ref2) {
+  if (ref2 === "#") return [];
+  if (!ref2.startsWith("#/")) return null;
+  if (/%2f|%00/i.test(ref2) || ref2.includes("\0")) return null;
+  try {
+    return ref2.slice(2).split("/").map(
+      (part) => decodeURIComponent(part).replace(/~1/g, "/").replace(/~0/g, "~")
+    );
+  } catch {
+    return null;
+  }
+}
+const formatSegment = (part) => "/" + encodeURIComponent(part.replace(/~/g, "~0").replace(/\//g, "~1"));
+const DYNAMIC_REF_KEYWORDS = ["$dynamicRef", "$recursiveRef"];
+function stripSchemaPatterns(schema) {
+  const positions = [];
+  const rawRefs = [];
+  let hasIdentifier = false;
+  const analyze = (node, parent) => {
+    const id2 = positions.length;
+    const position = {
+      node,
+      parent,
+      children: /* @__PURE__ */ new Map(),
+      direct: false,
+      dynamic: false
+    };
+    positions.push(position);
+    if (!isObject(node)) return id2;
+    if (IDENTIFIER_KEYWORDS.some((key) => key in node)) hasIdentifier = true;
+    if (typeof node.pattern === "string") position.direct = true;
+    if (isObject(node.patternProperties) && Object.keys(node.patternProperties).length > 0) {
+      position.direct = true;
+    }
+    if (typeof node.$ref === "string") rawRefs.push([id2, node.$ref]);
+    if (DYNAMIC_REF_KEYWORDS.some((key) => key in node)) {
+      position.dynamic = true;
+    }
+    for (const rel of childRels(node)) {
+      position.children.set(relKey(rel), analyze(getAt(node, rel), id2));
+    }
+    return id2;
+  };
+  analyze(schema, -1);
+  const resolve2 = (segments) => {
+    let current = 0;
+    for (let i2 = 0; i2 < segments.length; ) {
+      const { children } = positions[current];
+      const single = children.get(segments[i2]);
+      if (single !== void 0) {
+        current = single;
+        i2 += 1;
+        continue;
+      }
+      if (i2 + 1 >= segments.length) return null;
+      const pair = children.get(`${segments[i2]}\0${segments[i2 + 1]}`);
+      if (pair === void 0) return null;
+      current = pair;
+      i2 += 2;
+    }
+    return current;
+  };
+  const referrers = /* @__PURE__ */ new Map();
+  for (const [id2, ref2] of rawRefs) {
+    const segments = parseLocalRef(ref2);
+    const target = segments === null ? null : resolve2(segments);
+    positions[id2].ref = target;
+    if (target !== null) {
+      const list = referrers.get(target) ?? [];
+      list.push(id2);
+      referrers.set(target, list);
+    }
+  }
+  const tainted = new Uint8Array(positions.length);
+  const work = [];
+  const taint = (id2) => {
+    if (id2 < 0 || tainted[id2]) return;
+    tainted[id2] = 1;
+    work.push(id2);
+  };
+  positions.forEach((position, id2) => {
+    if (position.direct || position.dynamic || position.ref === null) {
+      taint(id2);
+    }
+  });
+  while (work.length > 0) {
+    const id2 = work.pop();
+    taint(positions[id2].parent);
+    for (const referrer of referrers.get(id2) ?? []) taint(referrer);
+  }
+  let stripped = 0;
+  let skipped = 0;
+  const outParent = new Int32Array(positions.length).fill(-2);
+  const outRel = new Array(positions.length);
+  const refSites = [];
+  const holding = [];
+  const root = isObject(schema) ? schema : void 0;
+  const takenNames = new Set(
+    isObject(root?.definitions) ? Object.keys(root.definitions) : []
+  );
+  let nextName = 0;
+  const emit = (id2) => {
+    const { node, children } = positions[id2];
+    if (!isObject(node)) return node;
+    const childOf = (rel) => children.get(relKey(rel));
+    const relocate = (rel) => holding.push(childOf(rel));
+    if (positions[id2].ref === null) {
+      childRels(node).forEach(relocate);
+      skipped++;
+      return {};
+    }
+    const copy = { ...node };
+    const isTainted = (rel) => tainted[childOf(rel)] === 1;
+    if (typeof copy.pattern === "string") {
+      delete copy.pattern;
+      stripped++;
+    }
+    if (isObject(copy.patternProperties) && Object.keys(copy.patternProperties).length > 0) {
+      for (const name2 of Object.keys(copy.patternProperties)) {
+        if (isSchema(copy.patternProperties[name2])) {
+          relocate(["patternProperties", name2]);
+        }
+        stripped++;
+      }
+      delete copy.patternProperties;
+      if ("additionalProperties" in copy) {
+        if (isSchema(copy.additionalProperties)) {
+          relocate(["additionalProperties"]);
+        }
+        delete copy.additionalProperties;
+        skipped++;
+      }
+    }
+    const dropIfTainted = (keyword2, alsoDrop = []) => {
+      if (!(keyword2 in copy)) return;
+      const rels = childRels({ [keyword2]: copy[keyword2] });
+      if (!rels.some(isTainted)) return;
+      rels.forEach(relocate);
+      delete copy[keyword2];
+      for (const extra of alsoDrop) delete copy[extra];
+      skipped++;
+    };
+    dropIfTainted("not");
+    dropIfTainted("oneOf");
+    if (isSchema(copy.if) && isTainted(["if"])) {
+      for (const keyword2 of ["if", "then", "else"]) {
+        if (isSchema(copy[keyword2])) relocate([keyword2]);
+        delete copy[keyword2];
+      }
+      skipped++;
+    }
+    dropIfTainted("contains", ["minContains", "maxContains"]);
+    if (tainted[id2]) {
+      for (const keyword2 of ["unevaluatedProperties", "unevaluatedItems"]) {
+        if (keyword2 in copy) {
+          if (isSchema(copy[keyword2])) relocate([keyword2]);
+          delete copy[keyword2];
+          skipped++;
+        }
+      }
+    }
+    for (const keyword2 of DYNAMIC_REF_KEYWORDS) {
+      if (keyword2 in copy) {
+        delete copy[keyword2];
+        skipped++;
+      }
+    }
+    const target = positions[id2].ref;
+    if (typeof copy.$ref === "string" && typeof target === "number") {
+      refSites.push({ node: copy, target });
+    }
+    const cloned = /* @__PURE__ */ new Set();
+    for (const rel of childRels(copy)) {
+      const child = childOf(rel);
+      outParent[child] = id2;
+      outRel[child] = rel;
+      const sub = emit(child);
+      if (rel.length === 1) {
+        copy[rel[0]] = sub;
+        continue;
+      }
+      const [keyword2, name2] = rel;
+      if (!cloned.has(keyword2)) {
+        cloned.add(keyword2);
+        const container = copy[keyword2];
+        copy[keyword2] = Array.isArray(container) ? [...container] : { ...container };
+      }
+      copy[keyword2][name2] = sub;
+    }
+    return copy;
+  };
+  outParent[0] = -1;
+  outRel[0] = [];
+  const output = emit(0);
+  if (isObject(output) && holding.length > 0) {
+    const definitions2 = isObject(output.definitions) ? { ...output.definitions } : {};
+    for (const id2 of holding) {
+      let name2;
+      do {
+        name2 = `${HOLDING_PREFIX}${nextName++}`;
+      } while (takenNames.has(name2));
+      takenNames.add(name2);
+      outParent[id2] = 0;
+      outRel[id2] = ["definitions", name2];
+      definitions2[name2] = emit(id2);
+    }
+    output.definitions = definitions2;
+  }
+  const pointers = /* @__PURE__ */ new Map();
+  const pointerOf = (id2) => {
+    if (outParent[id2] === -2) return void 0;
+    if (id2 === 0) return "#";
+    const memo = pointers.get(id2);
+    if (memo !== void 0) return memo;
+    const chain = [];
+    let current = id2;
+    while (current !== 0 && !pointers.has(current)) {
+      chain.push(current);
+      current = outParent[current];
+    }
+    let pointer = current === 0 ? "#" : pointers.get(current);
+    for (let i2 = chain.length - 1; i2 >= 0; i2--) {
+      const link = chain[i2];
+      pointer += outRel[link].map(formatSegment).join("");
+      pointers.set(link, pointer);
+    }
+    return pointer;
+  };
+  for (const site of refSites) {
+    site.node.$ref = pointerOf(site.target);
+  }
+  return { schema: output, stripped, skipped, validate: !hasIdentifier };
+}
+function schemaNote(result) {
+  if (!result.validate) {
+    return "this schema was not validated: it declares an $id or $anchor, which the Inspector does not resolve";
+  }
+  if (result.stripped === 0 && result.skipped === 0) return void 0;
+  return patternsNotEvaluatedNote(result.stripped, result.skipped);
+}
+function patternsNotEvaluatedNote(stripped, skipped = 0) {
+  const parts = [];
+  if (stripped > 0) {
+    parts.push(
+      `${stripped} regex pattern(s) in this schema were not evaluated`
+    );
+  }
+  if (skipped > 0) {
+    parts.push(
+      `${skipped} check(s) in this schema were skipped because they depend on an unevaluated pattern or an unresolvable $ref`
+    );
+  }
+  return parts.join("; ");
+}
 const ajv$2 = new Ajv$1();
 const toolOutputValidators = /* @__PURE__ */ new Map();
+const toolOutputSchemaNotes = /* @__PURE__ */ new Map();
 function cacheToolOutputSchemas(tools) {
   toolOutputValidators.clear();
+  toolOutputSchemaNotes.clear();
   for (const tool of tools) {
     if (tool.outputSchema) {
       try {
-        const validator = ajv$2.compile(tool.outputSchema);
-        toolOutputValidators.set(tool.name, validator);
+        const result = stripSchemaPatterns(tool.outputSchema);
+        const note = schemaNote(result);
+        if (result.validate) {
+          toolOutputValidators.set(
+            tool.name,
+            ajv$2.compile(result.schema)
+          );
+        }
+        if (note !== void 0) toolOutputSchemaNotes.set(tool.name, note);
       } catch (error) {
         console.warn(
           `Failed to compile output schema for tool ${tool.name}:`,
@@ -29932,20 +30265,23 @@ function getToolOutputValidator(toolName) {
 }
 function validateToolOutput(toolName, structuredContent) {
   const validator = getToolOutputValidator(toolName);
+  const toolNote = toolOutputSchemaNotes.get(toolName);
+  const note = toolNote === void 0 ? {} : { note: toolNote };
   if (!validator) {
-    return { isValid: true };
+    return toolNote === void 0 ? { isValid: true } : { isValid: true, validated: false, note: toolNote };
   }
   const isValid2 = validator(structuredContent);
   if (!isValid2) {
     return {
       isValid: false,
-      error: ajv$2.errorsText(validator.errors)
+      error: ajv$2.errorsText(validator.errors),
+      ...note
     };
   }
-  return { isValid: true };
+  return { isValid: true, ...note };
 }
 function hasOutputSchema(toolName) {
-  return toolOutputValidators.has(toolName);
+  return toolOutputValidators.has(toolName) || toolOutputSchemaNotes.has(toolName);
 }
 function generateDefaultValue(schema, propertyName, parentSchema) {
   if ("default" in schema && schema.default !== void 0) {
@@ -57143,7 +57479,7 @@ const useTheme = () => {
     [theme, setThemeWithSideEffect]
   );
 };
-const version = "1.0.3";
+const version = "1.0.4";
 var __defProp$2 = Object.defineProperty;
 var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
 var [createTooltipContext, createTooltipScope] = /* @__PURE__ */ createContextScope("Tooltip", [
@@ -59409,14 +59745,20 @@ const ToolResults = ({
         /* @__PURE__ */ jsxRuntimeExports.jsx("h5", { className: "font-semibold mb-2 text-sm", children: "Structured Content:" }),
         /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "bg-gray-50 dark:bg-gray-900 p-3 rounded-lg", children: [
           /* @__PURE__ */ jsxRuntimeExports.jsx(JsonView, { data: structuredResult.structuredContent }),
-          validationResult && /* @__PURE__ */ jsxRuntimeExports.jsx(
+          validationResult && /* @__PURE__ */ jsxRuntimeExports.jsxs(
             "div",
             {
               className: `mt-2 p-2 rounded text-sm ${validationResult.isValid ? "bg-green-100 dark:bg-green-900 text-green-800 dark:text-green-200" : "bg-red-100 dark:bg-red-900 text-red-800 dark:text-red-200"}`,
-              children: validationResult.isValid ? "✓ Valid according to output schema" : /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
-                "✗ Validation Error: ",
-                validationResult.error
-              ] })
+              children: [
+                "validated" in validationResult && validationResult.validated === false ? "Not validated against output schema" : validationResult.isValid ? "✓ Valid according to output schema" : /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+                  "✗ Validation Error: ",
+                  validationResult.error
+                ] }),
+                "note" in validationResult && validationResult.note && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "mt-1 text-xs opacity-80", children: [
+                  "⚠ ",
+                  validationResult.note
+                ] })
+              ]
             }
           )
         ] })
@@ -59427,7 +59769,11 @@ const ToolResults = ({
       ] }),
       !structuredResult.structuredContent && validationResult && !validationResult.isValid && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "mb-4", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "bg-red-100 dark:bg-red-900 text-red-800 dark:text-red-200 p-2 rounded text-sm", children: [
         "✗ Validation Error: ",
-        validationResult.error
+        validationResult.error,
+        "note" in validationResult && validationResult.note && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "mt-1 text-xs opacity-80", children: [
+          "⚠ ",
+          validationResult.note
+        ] })
       ] }) }),
       structuredResult.content.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "mb-4", children: [
         structuredResult.structuredContent && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
@@ -66726,6 +67072,14 @@ const ElicitationRequest = ({
   const [showUrlConfirm, setShowUrlConfirm] = reactExports.useState(false);
   const requestData = request.request;
   const isUrlMode = requestData.mode === "url";
+  const sanitized = reactExports.useMemo(
+    () => isUrlMode ? void 0 : stripSchemaPatterns(
+      requestData.requestedSchema
+    ),
+    [isUrlMode, requestData]
+  );
+  const regexFreeSchema = sanitized?.schema;
+  const sanitizedNote = sanitized && schemaNote(sanitized);
   reactExports.useEffect(() => {
     if (isUrlMode) return;
     const defaultValue = generateDefaultValue(
@@ -66885,13 +67239,15 @@ const ElicitationRequest = ({
       if (!validateFormData(formData, formRequest.requestedSchema)) {
         return;
       }
-      const ajv2 = new Ajv$1();
-      const validate2 = ajv2.compile(formRequest.requestedSchema);
-      const isValid2 = validate2(formData);
-      if (!isValid2) {
-        const errorMessage = ajv2.errorsText(validate2.errors);
-        setValidationError(errorMessage);
-        return;
+      if (sanitized?.validate) {
+        const ajv2 = new Ajv$1();
+        const validate2 = ajv2.compile(regexFreeSchema);
+        const isValid2 = validate2(formData);
+        if (!isValid2) {
+          const errorMessage = ajv2.errorsText(validate2.errors);
+          setValidationError(errorMessage);
+          return;
+        }
       }
       onResolve(request.id, {
         action: "accept",
@@ -66937,7 +67293,7 @@ const ElicitationRequest = ({
             /* @__PURE__ */ jsxRuntimeExports.jsx(
               DynamicJsonForm,
               {
-                schema: formRequest.requestedSchema,
+                schema: regexFreeSchema,
                 value: formData,
                 onChange: (newValue) => {
                   setFormData(newValue);
@@ -66945,6 +67301,10 @@ const ElicitationRequest = ({
                 }
               }
             ),
+            sanitizedNote && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "mt-2 text-xs text-muted-foreground", children: [
+              "⚠ ",
+              sanitizedNote
+            ] }),
             validationError && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "mt-4 p-3 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-md", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "text-sm text-red-600 dark:text-red-400", children: [
               /* @__PURE__ */ jsxRuntimeExports.jsx("strong", { children: "Validation Error:" }),
               " ",
@@ -68053,13 +68413,13 @@ const App = () => {
   ) });
   if (window.location.pathname === OAUTH_CALLBACK_PATH) {
     const OAuthCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthCallback-jbB02Bt3.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthCallback-Cb6VJMaq.js"), true ? [] : void 0)
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsxRuntimeExports.jsx(OAuthCallback, { onConnect: onOAuthConnect }) });
   }
   if (window.location.pathname === OAUTH_DEBUG_CALLBACK_PATH) {
     const OAuthDebugCallback = React.lazy(
-      () => __vitePreload(() => import("./OAuthDebugCallback-VeJ8bP3s.js"), true ? [] : void 0)
+      () => __vitePreload(() => import("./OAuthDebugCallback-CgAV2c_T.js"), true ? [] : void 0)
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsxRuntimeExports.jsx(OAuthDebugCallback, { onConnect: onOAuthDebugConnect }) });
   }

package/client/dist/assets/{index-DXy0twoH.css → index-D-iperlR.css}

@@ -1783,6 +1783,9 @@ video {
 .opacity-70 {
   opacity: 0.7;
 }
+.opacity-80 {
+  opacity: 0.8;
+}
 .opacity-90 {
   opacity: 0.9;
 }

package/client/dist/index.html

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/mcp.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>MCP Inspector</title>
-    <script type="module" crossorigin src="/assets/index-C2CDzlVy.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DXy0twoH.css">
+    <script type="module" crossorigin src="/assets/index-Bvgm3HOZ.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D-iperlR.css">
   </head>
   <body>
     <div id="root" class="w-full"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/inspector",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Model Context Protocol inspector",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Model Context Protocol a Series of LF Projects, LLC.",
@@ -53,9 +53,9 @@
     "check-version": "node scripts/check-version-consistency.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/inspector-cli": "^1.0.3",
-    "@modelcontextprotocol/inspector-client": "^1.0.3",
-    "@modelcontextprotocol/inspector-server": "^1.0.3",
+    "@modelcontextprotocol/inspector-cli": "^1.0.4",
+    "@modelcontextprotocol/inspector-client": "^1.0.4",
+    "@modelcontextprotocol/inspector-server": "^1.0.4",
     "@modelcontextprotocol/sdk": "^1.25.2",
     "concurrently": "^9.2.0",
     "node-fetch": "^3.3.2",