@cyanheads/mcp-ts-core 0.13.2 → 0.13.4

package/dist/mcp-server/tools/utils/inputPrevalidation.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview The ordered step raw `tools/call` arguments pass through before
+ * — and, for one stage, after — the `input` schema parses them.
+ *
+ * Strict inputs (#232) reject an unrecognized root key by name, which is right
+ * for a misspelling the caller can fix and wrong for the three cases collected
+ * here, where the arguments the model wrote are correct and something between
+ * the model and the schema is not:
+ *
+ * 1. **Client-added keys (#453)** — a placeholder, a call description, a call
+ *    id, or an `arguments`-level `_meta` block the model never wrote and cannot
+ *    remove. Dropped before parsing.
+ * 2. **Key aliases (#452)** — a declared `inputAliases` entry, or the same name
+ *    in another case style (`max_results` for `maxResults`). Rewritten to the
+ *    canonical key before parsing. A one-to-one mapping fixed ahead of time, not
+ *    the nearest-key guess #232 rejected.
+ * 3. **Representation repair (#234)** — a JSON-stringified array where an array
+ *    was declared. Applied only *after* the parse has already failed, and kept
+ *    only when it flips the arguments from invalid to valid: the author's schema
+ *    is the sole arbiter, so a repair can never touch input that was already
+ *    valid.
+ *
+ * All three are on by default and each has a server-level switch on
+ * `createApp({ input })` / `createWorkerHandler({ input })`. None of them
+ * changes what `tools/list` advertises, and none appears in a response: a drop,
+ * a rewrite, and a repair each emit one debug log and one counter increment
+ * instead.
+ *
+ * The split between the two is deliberate. Counter attributes are bounded and
+ * author- or framework-defined — the ignore-list entry that matched, the
+ * declared key a rewrite resolved to — because a metric label carrying the
+ * caller's own key text mints a permanent time series per spelling a client
+ * invents (#114). The raw key and alias go to the debug log, which is where an
+ * operator looks when a counter shows a new client artifact and where
+ * cardinality costs nothing.
+ *
+ * @module src/mcp-server/tools/utils/inputPrevalidation
+ */
+import { type RequestContext } from '../../../utils/internal/requestContext.js';
+import type { AnyToolDefinition } from './toolDefinition.js';
+/**
+ * Server-level switches for the pre-validation step, set once via
+ * `createApp({ input })`. Every stage is on with no configuration; an entry
+ * here either extends a stage or turns it off for the whole server. There is no
+ * per-tool switch — a definition's only say is the `inputAliases` it declares.
+ */
+export interface InputHandlingOptions {
+    /**
+     * Rewrite an undeclared root key whose case-folded form (`-`/`_` stripped,
+     * lowercased) matches exactly one declared key. `false` leaves declared
+     * `inputAliases` working and restores rejection for undeclared variants.
+     * Default `true`.
+     */
+    caseStyleAliases?: boolean;
+    /**
+     * Retry a failed parse once against repaired argument *values* — a
+     * JSON-stringified array parsed back into an array. `false` restores the
+     * single-parse behavior exactly. Default `true`.
+     */
+    coerce?: boolean;
+    /**
+     * Additional root keys to drop when the tool does not declare them, on top of
+     * the built-in client artifacts (`_meta`, `tool_call_description`,
+     * `toolCallId`). `false` disables the stage, so every undeclared key is
+     * rejected by name as it was before. Default: the built-in list only.
+     */
+    ignoreKeys?: readonly string[] | false;
+}
+/** One increment per repaired call, not per repaired value. */
+export declare function countCoerced(toolName: string, context: RequestContext | undefined): void;
+/**
+ * `Max-Results`, `max_results`, and `maxResults` all fold to `maxresults`.
+ *
+ * Exported so `lint:mcp` decides alias ambiguity by the same fold the rewrite
+ * uses — a rule computing its own would pass a definition the runtime declines
+ * to rewrite, or fail one it rewrites happily.
+ */
+export declare function foldArgumentKey(key: string): string;
+/**
+ * Runs the pre-parse half of the step — drop client-added keys, then rewrite
+ * key aliases — and returns the arguments to parse.
+ *
+ * Returns the caller's own object unchanged when nothing applied, so the common
+ * path allocates nothing. Non-object arguments are handed straight back: the
+ * schema's own rejection already says what arrived.
+ */
+export declare function prevalidateToolArguments(def: AnyToolDefinition, args: unknown, options: InputHandlingOptions | undefined, context: RequestContext | undefined): unknown;
+/**
+ * Parses back a string whose trimmed form is a JSON array, at each path the
+ * failed parse's issues named. Keys are never added, dropped, or renamed, and
+ * a value no issue points at is returned untouched.
+ *
+ * **Targeted, not a full walk.** A rejection names exactly the values the schema
+ * could not accept, and repairing anything else loses repairs that should have
+ * succeeded: one call carrying a stringified array for an array field *and* a
+ * free-text field legitimately holding `"[1,2]"` would have both rewritten, the
+ * re-parse would fail on the free-text field, and the whole call would be
+ * rejected over a value that was valid all along. An `invalid_union` issue's
+ * outer path counts like any other — that is the value the union rejected.
+ *
+ * `JSON.parse` is the exact inverse of the `JSON.stringify` that produced the
+ * value, so this undoes a known encoding rather than matching a nearest
+ * candidate — the distinction that makes it safe where nearest-key matching is
+ * not (#232). Safety does not rest on that alone: {@link parseToolArguments}
+ * runs this only after validation has already failed and keeps the result only
+ * when it then passes.
+ *
+ * Returns the argument itself when nothing was repairable, which is the signal
+ * the caller uses to skip the second parse.
+ */
+export declare function repairRepresentations(args: unknown, issues: ReadonlyArray<{
+    readonly path: ReadonlyArray<PropertyKey>;
+}>): unknown;
+//# sourceMappingURL=inputPrevalidation.d.ts.map

package/dist/mcp-server/tools/utils/inputPrevalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputPrevalidation.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/utils/inputPrevalidation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAMH,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,oCAAoC,CAAC;AAW5C,OAAO,KAAK,EAAE,iBAAiB,EAAmB,MAAM,qBAAqB,CAAC;AAM9E;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAAC;CACxC;AAoED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI,CAexF;AA8CD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAyND;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,oBAAoB,GAAG,SAAS,EACzC,OAAO,EAAE,cAAc,GAAG,SAAS,GAClC,OAAO,CAcT;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;CAAE,CAAC,GACnE,OAAO,CAST"}

package/dist/mcp-server/tools/utils/inputPrevalidation.js

@@ -0,0 +1,428 @@
+/**
+ * @fileoverview The ordered step raw `tools/call` arguments pass through before
+ * — and, for one stage, after — the `input` schema parses them.
+ *
+ * Strict inputs (#232) reject an unrecognized root key by name, which is right
+ * for a misspelling the caller can fix and wrong for the three cases collected
+ * here, where the arguments the model wrote are correct and something between
+ * the model and the schema is not:
+ *
+ * 1. **Client-added keys (#453)** — a placeholder, a call description, a call
+ *    id, or an `arguments`-level `_meta` block the model never wrote and cannot
+ *    remove. Dropped before parsing.
+ * 2. **Key aliases (#452)** — a declared `inputAliases` entry, or the same name
+ *    in another case style (`max_results` for `maxResults`). Rewritten to the
+ *    canonical key before parsing. A one-to-one mapping fixed ahead of time, not
+ *    the nearest-key guess #232 rejected.
+ * 3. **Representation repair (#234)** — a JSON-stringified array where an array
+ *    was declared. Applied only *after* the parse has already failed, and kept
+ *    only when it flips the arguments from invalid to valid: the author's schema
+ *    is the sole arbiter, so a repair can never touch input that was already
+ *    valid.
+ *
+ * All three are on by default and each has a server-level switch on
+ * `createApp({ input })` / `createWorkerHandler({ input })`. None of them
+ * changes what `tools/list` advertises, and none appears in a response: a drop,
+ * a rewrite, and a repair each emit one debug log and one counter increment
+ * instead.
+ *
+ * The split between the two is deliberate. Counter attributes are bounded and
+ * author- or framework-defined — the ignore-list entry that matched, the
+ * declared key a rewrite resolved to — because a metric label carrying the
+ * caller's own key text mints a permanent time series per spelling a client
+ * invents (#114). The raw key and alias go to the debug log, which is where an
+ * operator looks when a counter shows a new client artifact and where
+ * cardinality costs nothing.
+ *
+ * @module src/mcp-server/tools/utils/inputPrevalidation
+ */
+import { logger } from '../../../utils/internal/logger.js';
+import { requestContextService, withExtra, } from '../../../utils/internal/requestContext.js';
+import { ATTR_MCP_INPUT_ALIAS_KIND, ATTR_MCP_INPUT_COERCION, ATTR_MCP_INPUT_IGNORE_RULE, ATTR_MCP_INPUT_TARGET, ATTR_MCP_TOOL_NAME, } from '../../../utils/telemetry/attributes.js';
+import { createCounter } from '../../../utils/telemetry/metrics.js';
+import { scanHeaderDesignations } from './headerParam.js';
+import { inputVariants, isDiscriminatedUnionSchema, zodDef } from './schemaShape.js';
+/**
+ * Root keys known to be added by a client rather than written by the model, so
+ * rejecting them fails a call whose arguments were all correct. `_meta` belongs
+ * on `params`, not inside `arguments`; the other two are call bookkeeping.
+ */
+const BUILT_IN_IGNORED_KEYS = ['_meta', 'tool_call_description', 'toolCallId'];
+/** The one repair {@link repairRepresentations} performs, as the counter labels it. */
+const COERCION_KIND_STRINGIFIED_ARRAY = 'stringified_array';
+/**
+ * What the ignored-key counter reports for a key the underscore heuristic
+ * dropped. The key itself is caller-supplied and stays in the debug log.
+ */
+const UNDERSCORE_RULE = 'underscore_prefix';
+// ---------------------------------------------------------------------------
+// Telemetry
+// ---------------------------------------------------------------------------
+let ignoredKeyCounter;
+let aliasedCounter;
+let coercedCounter;
+/**
+ * Lazily created — a server whose callers never trip a stage emits no series.
+ *
+ * `rule` is the ignore-list entry that matched or {@link UNDERSCORE_RULE}, never
+ * the dropped key itself: the key is the caller's text, and one client inventing
+ * `_callId`, `_call_id`, `_callID` would mint three permanent series (#114). The
+ * ignore list is author- and framework-defined, so it is safe to name.
+ */
+function countIgnoredKey(toolName, rule) {
+    ignoredKeyCounter ??= createCounter('mcp.input.ignored_key', 'Client-added root argument keys dropped before validation', '{keys}');
+    ignoredKeyCounter.add(1, {
+        [ATTR_MCP_TOOL_NAME]: toolName,
+        [ATTR_MCP_INPUT_IGNORE_RULE]: rule,
+    });
+}
+/**
+ * Labelled by the canonical *target* and which half of the stage fired — both
+ * bounded by the definition. The alias is the caller's text, and the case-style
+ * half accepts every `-`/`_`/case permutation of a declared key, so labelling it
+ * would put an unbounded set on a permanent series (#114).
+ */
+function countAliased(toolName, target, kind) {
+    aliasedCounter ??= createCounter('mcp.input.aliased', 'Root argument keys rewritten to their canonical spelling', '{keys}');
+    aliasedCounter.add(1, {
+        [ATTR_MCP_TOOL_NAME]: toolName,
+        [ATTR_MCP_INPUT_TARGET]: target,
+        [ATTR_MCP_INPUT_ALIAS_KIND]: kind,
+    });
+}
+/** One increment per repaired call, not per repaired value. */
+export function countCoerced(toolName, context) {
+    coercedCounter ??= createCounter('mcp.input.coerced', 'Tool calls that validated only after a representation repair', '{calls}');
+    coercedCounter.add(1, {
+        [ATTR_MCP_TOOL_NAME]: toolName,
+        [ATTR_MCP_INPUT_COERCION]: COERCION_KIND_STRINGIFIED_ARRAY,
+    });
+    debugLog(`Tool '${toolName}': arguments validated after repairing a stringified array.`, context, { toolName, coercion: COERCION_KIND_STRINGIFIED_ARRAY });
+}
+/**
+ * The step's own debug channel. A pre-validation decision is invisible in the
+ * response by design, so the log is the only place a server operator sees that
+ * a key was dropped or moved.
+ */
+function debugLog(message, context, extra) {
+    const base = context ?? requestContextService.createRequestContext({ operation: 'ToolInputPrevalidation' });
+    logger.debug(message, withExtra(base, extra));
+}
+const plans = new WeakMap();
+/**
+ * `Max-Results`, `max_results`, and `maxResults` all fold to `maxresults`.
+ *
+ * Exported so `lint:mcp` decides alias ambiguity by the same fold the rewrite
+ * uses — a rule computing its own would pass a definition the runtime declines
+ * to rewrite, or fail one it rewrites happily.
+ */
+export function foldArgumentKey(key) {
+    return key.replaceAll(/[-_]/g, '').toLowerCase();
+}
+/**
+ * True when the author opened the object themselves. `.strict()` also records a
+ * catchall — a `ZodNever` one — so the type of the catchall, not its presence,
+ * is what separates an open root from a strict one.
+ */
+function isOpenObject(schema) {
+    const catchall = schema.def.catchall;
+    return catchall !== undefined && zodDef(catchall)?.type !== 'never';
+}
+function buildVariantPlan(schema) {
+    const keys = new Set(Object.keys(schema.shape));
+    const folded = new Map();
+    for (const key of keys) {
+        const fold = foldArgumentKey(key);
+        folded.set(fold, folded.has(fold) ? null : key);
+    }
+    return { folded, keys, open: isOpenObject(schema) };
+}
+/**
+ * Derives the plan for a definition's input root, memoized on the root schema —
+ * the header scan emits JSON Schema, which is far too much work to repeat per
+ * call.
+ */
+function planFor(input) {
+    const cached = plans.get(input);
+    if (cached)
+        return cached;
+    const variants = inputVariants(input).map((schema) => ({
+        plan: buildVariantPlan(schema),
+        schema,
+    }));
+    const allKeys = new Set();
+    for (const variant of variants)
+        for (const key of variant.plan.keys)
+            allKeys.add(key);
+    // A union root can carry no valid designation at all (every field sits under
+    // `oneOf`), and an invalid one already failed in `tool()`, so this only ever
+    // collects root properties of an object root.
+    const scan = scanHeaderDesignations(input);
+    const headerTargets = new Set(scan?.valid
+        ? scan.designations.flatMap(({ path }) => {
+            const step = path.length === 1 ? path[0] : undefined;
+            return step?.kind === 'property' ? [step.key] : [];
+        })
+        : []);
+    const discriminator = isDiscriminatedUnionSchema(input)
+        ? zodDef(input)?.discriminator
+        : undefined;
+    const plan = {
+        allKeys,
+        anyOpen: variants.some((variant) => variant.plan.open),
+        discriminator,
+        headerTargets,
+        underscoreDeclared: [...allKeys].some((key) => key.startsWith('_')),
+        variants,
+    };
+    plans.set(input, plan);
+    return plan;
+}
+/**
+ * The variant the arguments select, or `undefined` when nothing selects one.
+ *
+ * An object root has exactly one. A union root has no single declared-key set
+ * until the discriminator is read, and a call whose discriminator is absent or
+ * unrecognized fails on the discriminator either way — so the rewrite stage
+ * declines rather than guessing a branch.
+ */
+function selectVariant(plan, args) {
+    if (plan.discriminator === undefined)
+        return plan.variants[0]?.plan;
+    if (!Object.hasOwn(args, plan.discriminator))
+        return undefined;
+    const value = args[plan.discriminator];
+    for (const variant of plan.variants) {
+        const field = variant.schema.shape[plan.discriminator];
+        if (field?.safeParse(value).success)
+            return variant.plan;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Stage 1 — drop client-added keys (#453)
+// ---------------------------------------------------------------------------
+/**
+ * Drops a root key the tool does not declare when it is either underscore-
+ * prefixed or on the ignore list. Three boundaries:
+ *
+ * - **A declared key is never dropped**, including a declared underscore-prefixed
+ *   one. On a union root "declared" is every variant's root keys, since the
+ *   matching variant is unknown until the discriminator is read.
+ * - **An author-opened root is untouched** — its extra keys reach the handler
+ *   today, and dropping them would delete data the author accepts on purpose.
+ * - **The underscore rule is off for a tool declaring any underscore-prefixed
+ *   key.** Otherwise a misspelled `_cursor` would be silently dropped instead of
+ *   rejected by name, which is the failure #232 removed. The ignore list still
+ *   applies there.
+ */
+function dropIgnoredKeys(def, args, plan, options, context) {
+    if (options?.ignoreKeys === false || plan.anyOpen)
+        return args;
+    const ignored = new Set([...BUILT_IN_IGNORED_KEYS, ...(options?.ignoreKeys ?? [])]);
+    const underscoreRule = !plan.underscoreDeclared;
+    let kept;
+    for (const key of Object.keys(args)) {
+        if (plan.allKeys.has(key))
+            continue;
+        const listed = ignored.has(key);
+        if (!listed && !(underscoreRule && key.startsWith('_')))
+            continue;
+        // Spread copies own properties by definition, so a caller's own `__proto__`
+        // survives as a key instead of re-prototyping the copy; `delete` on that own
+        // property is equally safe.
+        kept ??= { ...args };
+        delete kept[key];
+        countIgnoredKey(def.name, listed ? key : UNDERSCORE_RULE);
+        debugLog(`Tool '${def.name}': dropped client-added argument key '${key}'.`, context, {
+            toolName: def.name,
+            ignoredKey: key,
+            ignoreRule: listed ? key : UNDERSCORE_RULE,
+        });
+    }
+    return kept ?? args;
+}
+// ---------------------------------------------------------------------------
+// Stage 2 — key aliases (#452)
+// ---------------------------------------------------------------------------
+/**
+ * Rewrites root keys to their canonical spelling in two passes: the definition's
+ * declared `inputAliases`, then — unless `caseStyleAliases: false` — any
+ * undeclared key whose case-folded form names exactly one declared key.
+ *
+ * A rewrite applies only when the target key is absent; with both present the
+ * arguments pass through and the strict rejection fires as it does today. An
+ * author-opened root is never rewritten (an unknown key there is already
+ * accepted verbatim), and a `headerParam`-designated target is never rewritten
+ * *to*: the SDK cross-checks the `Mcp-Param-<Name>` header against the raw body
+ * before dispatch, so a later rewrite would hand the handler a value no
+ * intermediary attested.
+ */
+function applyAliases(def, args, plan, options, context) {
+    const declared = def.inputAliases;
+    const caseStyle = options?.caseStyleAliases !== false;
+    if (plan.anyOpen || (!declared && !caseStyle))
+        return args;
+    const variant = selectVariant(plan, args);
+    if (!variant)
+        return args;
+    let rewritten;
+    const current = () => rewritten ?? args;
+    const rewritable = (alias, target) => Object.hasOwn(current(), alias) &&
+        !variant.keys.has(alias) &&
+        variant.keys.has(target) &&
+        !plan.headerTargets.has(target) &&
+        !Object.hasOwn(current(), target);
+    const move = (alias, target, kind) => {
+        // `target` is a declared key read off the Zod shape, never caller text — an
+        // object literal resolves `__proto__` to the prototype setter rather than a
+        // key, so a shape cannot declare one and this assignment cannot reach it.
+        // `alias` is caller text, but it is only read and deleted, both own-property
+        // operations. The spread defines rather than assigns, so an own `__proto__`
+        // elsewhere in the arguments survives the copy.
+        rewritten ??= { ...args };
+        rewritten[target] = rewritten[alias];
+        delete rewritten[alias];
+        countAliased(def.name, target, kind);
+        debugLog(`Tool '${def.name}': rewrote argument key '${alias}' to '${target}'.`, context, {
+            toolName: def.name,
+            alias,
+            target,
+            aliasKind: kind,
+        });
+    };
+    for (const [alias, target] of Object.entries(declared ?? {})) {
+        if (rewritable(alias, target))
+            move(alias, target, 'declared');
+    }
+    if (caseStyle) {
+        // Snapshot first: `move` only ever removes an undeclared key and adds a
+        // declared one, so the remaining candidates are unaffected.
+        for (const key of Object.keys(current())) {
+            if (variant.keys.has(key))
+                continue;
+            const target = variant.folded.get(foldArgumentKey(key));
+            if (target && rewritable(key, target))
+                move(key, target, 'case_style');
+        }
+    }
+    return rewritten ?? args;
+}
+// ---------------------------------------------------------------------------
+// Public entry points
+// ---------------------------------------------------------------------------
+/**
+ * Runs the pre-parse half of the step — drop client-added keys, then rewrite
+ * key aliases — and returns the arguments to parse.
+ *
+ * Returns the caller's own object unchanged when nothing applied, so the common
+ * path allocates nothing. Non-object arguments are handed straight back: the
+ * schema's own rejection already says what arrived.
+ */
+export function prevalidateToolArguments(def, args, options, context) {
+    if (args === null || typeof args !== 'object' || Array.isArray(args))
+        return args;
+    const plan = planFor(def.input);
+    if (plan.variants.length === 0)
+        return args;
+    const record = args;
+    return applyAliases(def, dropIgnoredKeys(def, record, plan, options, context), plan, options, context);
+}
+/**
+ * Parses back a string whose trimmed form is a JSON array, at each path the
+ * failed parse's issues named. Keys are never added, dropped, or renamed, and
+ * a value no issue points at is returned untouched.
+ *
+ * **Targeted, not a full walk.** A rejection names exactly the values the schema
+ * could not accept, and repairing anything else loses repairs that should have
+ * succeeded: one call carrying a stringified array for an array field *and* a
+ * free-text field legitimately holding `"[1,2]"` would have both rewritten, the
+ * re-parse would fail on the free-text field, and the whole call would be
+ * rejected over a value that was valid all along. An `invalid_union` issue's
+ * outer path counts like any other — that is the value the union rejected.
+ *
+ * `JSON.parse` is the exact inverse of the `JSON.stringify` that produced the
+ * value, so this undoes a known encoding rather than matching a nearest
+ * candidate — the distinction that makes it safe where nearest-key matching is
+ * not (#232). Safety does not rest on that alone: {@link parseToolArguments}
+ * runs this only after validation has already failed and keeps the result only
+ * when it then passes.
+ *
+ * Returns the argument itself when nothing was repairable, which is the signal
+ * the caller uses to skip the second parse.
+ */
+export function repairRepresentations(args, issues) {
+    let repaired = args;
+    for (const issue of issues) {
+        if (issue.path.length === 0)
+            continue;
+        const current = readAt(repaired, issue.path);
+        const next = repairValue(current);
+        if (next !== current)
+            repaired = writeAt(repaired, issue.path, next);
+    }
+    return repaired;
+}
+/** The one repair: a JSON-array string back into the array it encodes. */
+function repairValue(value) {
+    if (typeof value !== 'string')
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('['))
+        return value;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return Array.isArray(parsed) ? parsed : value;
+    }
+    catch {
+        return value;
+    }
+}
+/** The value at `path`, or `undefined` when nothing owns one there. */
+function readAt(root, path) {
+    let cursor = root;
+    for (const segment of path) {
+        if (cursor === null || typeof cursor !== 'object')
+            return undefined;
+        if (!Object.hasOwn(cursor, segment))
+            return undefined;
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+/**
+ * Replaces the value at `path`, copying each container along the way and
+ * leaving the caller's own objects untouched.
+ *
+ * Object copies go through `Object.fromEntries`, which *defines* each property
+ * rather than assigning it. `copy[key] = value` would route a caller's own
+ * `__proto__` key — which `JSON.parse` creates as an ordinary own data property
+ * — through `Object.prototype`'s setter: the key would vanish and the copy's
+ * prototype would become whatever the caller sent, which Zod then reads
+ * inherited values from. Defining keeps the key and the prototype, and keeps
+ * this function's promise that no key is added, dropped, or renamed.
+ */
+function writeAt(root, path, value) {
+    const [head, ...rest] = path;
+    if (head === undefined)
+        return value;
+    if (Array.isArray(root)) {
+        const index = Number(head);
+        if (!Number.isInteger(index) || index < 0 || index >= root.length)
+            return root;
+        const copy = [...root];
+        copy[index] = writeAt(root[index], rest, value);
+        return copy;
+    }
+    if (root !== null && typeof root === 'object') {
+        const key = String(head);
+        if (!Object.hasOwn(root, key))
+            return root;
+        return Object.fromEntries(Object.entries(root).map(([entryKey, entryValue]) => [
+            entryKey,
+            entryKey === key ? writeAt(entryValue, rest, value) : entryValue,
+        ]));
+    }
+    return root;
+}
+//# sourceMappingURL=inputPrevalidation.js.map

package/dist/mcp-server/tools/utils/inputPrevalidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputPrevalidation.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/utils/inputPrevalidation.ts"],"names":[],"mappings":"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"}

package/dist/mcp-server/tools/utils/strictenRecord.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview What `strictenInput` threw away, kept where `lint:mcp` can read
+ * it (#358, #394).
+ *
+ * Zod 4 keys `.describe()` and `.meta()` to the schema **instance**, in
+ * `z.globalRegistry`, and `.strict()` is `catchall(z.never())` — a clone with no
+ * `_zod.parent` link, so it inherits no registry entry. `strictenInput` stores
+ * that clone, and whatever the author attached to the input root is gone:
+ * silently, since the linter reads the same stored schema the wire does and a
+ * root carries no describe anything would ask for.
+ *
+ * `tool()` is the only place both instances exist, so it records the discard
+ * here on the way past. The record is a symbol-keyed, non-enumerable property:
+ * invisible to `Object.keys`, `JSON.stringify`, a spread, `tools/list`, the
+ * server manifest and `_meta` alike, so nothing about what a client sees
+ * changes. The symbol comes from the global registry rather than a module
+ * binding, because `lint:mcp` can load the framework twice — the linter from
+ * the installed package, the definitions from wherever the server imports them
+ * — and a module-local key (or a `WeakMap`) would not be shared across the two.
+ *
+ * Re-applying the discarded entry to the strictened schema is separate, held
+ * work: it would change the advertised `inputSchema` bytes. This half changes
+ * none of them.
+ *
+ * @module src/mcp-server/tools/utils/strictenRecord
+ */
+/** One schema instance whose registry entry `strictenInput` did not carry over. */
+export interface StrictenDiscard {
+    /** The registry keys that were lost — `description` for `.describe()`, else `.meta()` keys. */
+    readonly keys: readonly string[];
+    /** Where it sat, in the linter's path vocabulary: `input`, or `input|<i>` for a variant. */
+    readonly scope: string;
+}
+/**
+ * Attaches the discards to a definition without making it part of the
+ * definition's value. Only called when something was actually discarded, so an
+ * unaffected definition carries no property at all.
+ */
+export declare function recordStrictenDiscard(definition: object, discards: readonly StrictenDiscard[]): void;
+/** The discards `tool()` recorded, or `undefined` when nothing was discarded. */
+export declare function readStrictenDiscard(definition: unknown): readonly StrictenDiscard[] | undefined;
+//# sourceMappingURL=strictenRecord.d.ts.map

package/dist/mcp-server/tools/utils/strictenRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strictenRecord.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/utils/strictenRecord.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,mFAAmF;AACnF,MAAM,WAAW,eAAe;IAC9B,+FAA+F;IAC/F,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,4FAA4F;IAC5F,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAID;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,SAAS,eAAe,EAAE,GACnC,IAAI,CAON;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,OAAO,GAAG,SAAS,eAAe,EAAE,GAAG,SAAS,CAI/F"}

package/dist/mcp-server/tools/utils/strictenRecord.js

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview What `strictenInput` threw away, kept where `lint:mcp` can read
+ * it (#358, #394).
+ *
+ * Zod 4 keys `.describe()` and `.meta()` to the schema **instance**, in
+ * `z.globalRegistry`, and `.strict()` is `catchall(z.never())` — a clone with no
+ * `_zod.parent` link, so it inherits no registry entry. `strictenInput` stores
+ * that clone, and whatever the author attached to the input root is gone:
+ * silently, since the linter reads the same stored schema the wire does and a
+ * root carries no describe anything would ask for.
+ *
+ * `tool()` is the only place both instances exist, so it records the discard
+ * here on the way past. The record is a symbol-keyed, non-enumerable property:
+ * invisible to `Object.keys`, `JSON.stringify`, a spread, `tools/list`, the
+ * server manifest and `_meta` alike, so nothing about what a client sees
+ * changes. The symbol comes from the global registry rather than a module
+ * binding, because `lint:mcp` can load the framework twice — the linter from
+ * the installed package, the definitions from wherever the server imports them
+ * — and a module-local key (or a `WeakMap`) would not be shared across the two.
+ *
+ * Re-applying the discarded entry to the strictened schema is separate, held
+ * work: it would change the advertised `inputSchema` bytes. This half changes
+ * none of them.
+ *
+ * @module src/mcp-server/tools/utils/strictenRecord
+ */
+const STRICTEN_DISCARD = Symbol.for('@cyanheads/mcp-ts-core:strictenDiscard');
+/**
+ * Attaches the discards to a definition without making it part of the
+ * definition's value. Only called when something was actually discarded, so an
+ * unaffected definition carries no property at all.
+ */
+export function recordStrictenDiscard(definition, discards) {
+    Object.defineProperty(definition, STRICTEN_DISCARD, {
+        configurable: true,
+        enumerable: false,
+        value: discards,
+        writable: false,
+    });
+}
+/** The discards `tool()` recorded, or `undefined` when nothing was discarded. */
+export function readStrictenDiscard(definition) {
+    if (definition === null || typeof definition !== 'object')
+        return undefined;
+    const value = definition[STRICTEN_DISCARD];
+    return Array.isArray(value) ? value : undefined;
+}
+//# sourceMappingURL=strictenRecord.js.map