@cyanheads/mcp-ts-core 0.13.13 → 0.13.14

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

@@ -14,9 +14,17 @@
  *    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, #479, #487)** — a JSON-stringified array or
- *    object where one was declared, or an integer where a string was. Applied
- *    only *after* the parse has already failed, and kept only when it flips the
+ * 3. **Representation repair (#234, #479, #487, #707, #602, #616, #570, #599,
+ *    #714)** — a JSON-stringified array or object where one was declared, an
+ *    integer where a string was, a string spelling a number or boolean where
+ *    only those are accepted, a lone string where an array was, or `null` for
+ *    an optional field, which is deleted — at any path the rejection renders,
+ *    inside the one union branch that survives selection included, at a
+ *    discriminator or literal tag no variant accepts, and inside what a
+ *    `z.preprocess()` made of the argument — tried first written in place at
+ *    the issue path, then written into the output, which takes the argument's
+ *    place only if the preprocess returns it unchanged. 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.
  *
@@ -39,9 +47,18 @@
  * debug log and one counter increment instead — for the attempt whose
  * arguments the handler receives, never one the parse discarded. A call they
  * cannot rescue is rejected with the rewrites and underscore-rule drops of the
- * attempt whose rejection it carries reported (#468), since without them the caller cannot
- * tell a bad value from a key that was moved or discarded; a repair the
- * re-parse discarded leaves no trace there.
+ * attempt whose rejection it carries reported (#468), since without them the
+ * caller cannot tell a bad value from a key that was moved or discarded, and
+ * with each alias sent beside its target named as one in the hint (#639),
+ * since an unknown or dropped key would send the caller looking for a typo. Its
+ * issues come from a parse with only the repairs that held applied (#706), so
+ * a value the schema accepted once repaired is not reported and one it refused
+ * is reported as sent — unless that parse validates, which only a union or a
+ * cross-field refinement allows, and the first parse is reported instead; the
+ * rejection itself never mentions a repair. A value that held only written in
+ * place below a transform that reorders or rewrites it is reported as sent
+ * too: the issues name positions in the transform's output, where a repair
+ * written in place is not.
  *
  * The split between log and counter is deliberate. Counter attributes are
  * bounded and author- or framework-defined — the ignore-list entry that
@@ -50,14 +67,15 @@
  * 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, at most their first 1,024 characters bounding its size
- * (#631) — and, on a rejection, back to the caller who sent them, whole, since
- * an error payload is per call rather than a permanent series.
+ * (#631) — and, on a rejection, back to the caller who sent them, cut the same
+ * way (#648), since an error payload is per call rather than a permanent series.
  *
  * @module src/mcp-server/tools/utils/inputPrevalidation
  */
 import type { ZodError } from 'zod';
 import { type RequestContext } from '../../../utils/internal/requestContext.js';
-import type { AnyToolDefinition } from './toolDefinition.js';
+import { type TransformCache, type TransformSite } from './schemaShape.js';
+import type { AnyToolDefinition, ToolInputSchema } 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
@@ -74,10 +92,14 @@ export interface InputHandlingOptions {
     caseStyleAliases?: boolean;
     /**
      * Retry a failed parse once against repaired argument *values* — a
-     * JSON-stringified array or object parsed back into what it encodes, or a
-     * safe integer sent where a string was expected turned into its decimal
-     * string. `false` turns the repair off, so each order of the key stages is
-     * parsed once, with the values as sent. Default `true`.
+     * JSON-stringified array or object parsed back into what it encodes, a safe
+     * integer sent where a string was expected turned into its decimal string, a
+     * string sent where only numbers or booleans are accepted turned into the
+     * one it spells (`"15"`, `"true"`), a lone string sent where an array was
+     * expected wrapped as its only element, and `null` sent for an optional
+     * field deleted so the field reads as unset. `false` turns the repair off,
+     * so each order of the key stages is parsed once, with the values as sent.
+     * Default `true`.
      */
     coerce?: boolean;
     /**
@@ -97,6 +119,10 @@ declare const COERCION_KINDS: {
     readonly stringified_array: 'a stringified array';
     readonly stringified_object: 'a stringified object';
     readonly integer_as_string: 'an integer sent for a string';
+    readonly string_as_number: 'a string sent for a number';
+    readonly string_as_boolean: 'a string sent for a boolean';
+    readonly string_as_array: 'a string sent for an array';
+    readonly null_as_absent: 'null sent for an optional field';
 };
 /** One repair {@link repairRepresentations} can perform. */
 export type CoercionKind = keyof typeof COERCION_KINDS;
@@ -104,12 +130,29 @@ export type CoercionKind = keyof typeof COERCION_KINDS;
 type AliasKind = 'case_style' | 'declared';
 /** One Zod issue from a failed parse of the arguments. */
 type ArgumentIssue = ZodError['issues'][number];
+/**
+ * A Zod issue and the full argument path it sits at. The path equals
+ * `issue.path` except for an issue lifted out of a union branch, whose
+ * branch-relative path follows the union's own (#492).
+ */
+export interface LocatedIssue {
+    readonly issue: ArgumentIssue;
+    readonly path: readonly PropertyKey[];
+    /**
+     * The one-literal issues other branches of an enclosing union raised at
+     * this same path — branches the rendering dropped for failing on one
+     * literal alone (#417). The repair reads the value as a plain union field
+     * holding those branches would, so a dropped `z.literal(5)` branch keeps `6`
+     * from becoming `"6"` (#570).
+     */
+    readonly rivals?: readonly ArgumentIssue[];
+}
 /**
  * What the pre-parse stages changed that the caller wrote, reported on an
  * argument rejection (#468) so a caller can tell a bad value from a key that
  * was moved or discarded. Keys only, never values.
  */
-export interface PrevalidationReport {
+interface PrevalidationReport {
     /** Root keys rewritten to their canonical spelling, in argument order. */
     readonly aliased: ReadonlyArray<{
         readonly alias: string;
@@ -137,6 +180,24 @@ export type PrevalidationChange = {
     readonly kind: 'dropped';
     readonly rule: string;
 };
+/**
+ * A declared key the caller sent together with an alias of it (#639). The
+ * alias stage leaves an alias in place when its target is already present, so
+ * the strict root rejects it as an unknown key, or the drop discards it as an
+ * undeclared underscore key — and naming it that way would send the caller
+ * looking for a typo when the problem is that two names for one field arrived.
+ */
+export interface AliasCollision {
+    /** The aliases left in place because `target` was already present, in argument order. */
+    readonly declined: readonly string[];
+    /**
+     * Every key the caller sent for `target`, in argument order: the key itself,
+     * the aliases rewritten to it, and the declined ones.
+     */
+    readonly keys: readonly string[];
+    /** The declared key. */
+    readonly target: string;
+}
 /** One ordering of the pre-parse stages — what {@link prevalidateToolArguments} hands the parse. */
 export interface PrevalidatedArguments {
     /** The arguments to parse — the caller's own object when nothing applied. */
@@ -147,22 +208,84 @@ export interface PrevalidatedArguments {
      * receives, and {@link recordPrevalidation} emits that one.
      */
     readonly changes: readonly PrevalidationChange[];
+    /**
+     * The aliases the alias stage declined because their target was already
+     * present, grouped by target, or `undefined` when it declined none. Worked
+     * out only when called: a rejection's hint is the one reader, so a call that
+     * validates never pays for it. Kept off `report`, which records what the
+     * stages changed: a rejection's hint names these keys, and `data.input` never
+     * does.
+     */
+    readonly collisions?: () => readonly AliasCollision[] | undefined;
     /** Present only when a rewrite or an underscore-rule drop happened. */
     readonly report?: PrevalidationReport;
 }
+/**
+ * One value {@link repairRepresentations} repaired: where it sits, what the
+ * caller sent there, and what replaces it — or, for `null_as_absent`, that the
+ * key is deleted. {@link applyRepairs} writes any set of them onto the caller's
+ * arguments, so a parse can be retried with only some of a call's repairs
+ * applied, and leaving a deletion out of the set keeps the caller's `null`.
+ *
+ * A value below a `z.preprocess()` or a `.transform().pipe()` sits in what the
+ * transform made of the argument, not in the argument itself (#599): `within`
+ * names each such transform, outermost first, and the repair is written into
+ * its output.
+ */
+export type Repair = ({
+    readonly kind: Exclude<CoercionKind, 'null_as_absent'>;
+    /** The full argument path the value sits at. */
+    readonly path: readonly PropertyKey[];
+    /** The value at `path` — the caller's own, or a transform's output there. */
+    readonly sent: unknown;
+    /** The value that replaces it. */
+    readonly value: unknown;
+} | {
+    readonly kind: 'null_as_absent';
+    /** The full argument path of the key that is deleted. */
+    readonly path: readonly PropertyKey[];
+    readonly sent: null;
+}) & {
+    /** The transforms above `path`, outermost first; absent when there are none. */
+    readonly within?: readonly TransformSite[];
+};
 /** What {@link repairRepresentations} produced. */
 export interface RepairedArguments {
     /** The repaired arguments — the input itself when nothing was repairable. */
     readonly args: unknown;
+    /**
+     * The arguments with each repair below a transform written in place instead
+     * — at its issue path in the arguments as sent, never into the transform's
+     * output — and the kinds they carry. Present only when such a repair was
+     * found; {@link parseToolArguments} parses it after {@link repairAsSent}'s
+     * repair and before `args`.
+     */
+    readonly inPlace?: {
+        readonly args: unknown;
+        readonly kinds: readonly CoercionKind[];
+    };
     /** Each kind that fired at least once, in {@link COERCION_KINDS} order. */
     readonly kinds: readonly CoercionKind[];
+    /** Every repair {@link RepairedArguments.args} carries, one per path, in issue order. */
+    readonly repairs: readonly Repair[];
+    /**
+     * The arguments without the original repairs `args` adds beside the
+     * rendered issues' own, and the kinds they carry. Present only when an
+     * original repair was added and these still differ from the input;
+     * {@link parseToolArguments} parses them when `args` fails.
+     */
+    readonly unaided?: {
+        readonly args: unknown;
+        readonly kinds: readonly CoercionKind[];
+    };
 }
 /**
  * Emits one counter increment and one debug log per change an attempt made, in
  * the order its stages made them. {@link parseToolArguments} calls it once per
  * call, for the attempt whose arguments the handler receives — or, on a
- * rejection, the first attempt, the one the rejection reports — so a key the
- * alias-first retry rewrote never also counts as dropped (#563).
+ * rejection, the attempt the rejection reports, which is the alias-first
+ * retry's when it ran — so a key the alias-first retry rewrote never also
+ * counts as dropped (#563).
  *
  * The key a record names is the caller's, of whatever length the caller wrote,
  * so the message and the field carry at most its first 1,024 characters, with
@@ -209,23 +332,62 @@ export declare function prevalidateAliasFirst(def: AnyToolDefinition, args: unkn
 /**
  * Undoes a representation slip at each path the failed parse's issues named:
  * a string whose trimmed form is a JSON array or object is parsed back into
- * what it encodes (#234, #479), and a safe integer where a string was expected
- * becomes its decimal string (#487). Keys are never added, dropped, or renamed,
- * and a value no issue points at is returned untouched.
+ * what it encodes (#234, #479), a safe integer where a string was expected
+ * becomes its decimal string (#487), a string where only numbers or booleans
+ * are accepted becomes the one it spells (#707), a lone string where an array
+ * was expected becomes its only element (#602), and `null` at a key the
+ * enclosing `z.object()` of `input` declares optional is deleted (#616). That
+ * deletion is the only key change: no key is added or renamed, none is dropped
+ * but a `null`-valued one, and a value no issue points at is returned
+ * untouched.
+ *
+ * **`null` means unset only where the schema says so.** The key must be one
+ * the enclosing object declares — resolved by {@link objectSchemaAt}, through
+ * wrappers and into the variant a discriminator selects — and its field must
+ * refuse `null` and accept `undefined`. A required field's `null` keeps its
+ * rejection, a `.nullable()` field never raises the issue, and a `z.record()`
+ * entry, a key under an author-opened catchall, and an array element are data
+ * whose key set is the meaning, so none is deleted. The value, not the issue
+ * code, is the trigger: `null` on an optional enum fails as `invalid_value`,
+ * whose message never says `null`.
  *
  * **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, and
- * the only one read: a number inside one branch of a union field stays as sent.
+ * rejected over a value that was valid all along.
+ *
+ * **The issues the rejection renders.** {@link parseToolArguments} passes the
+ * list the rejection's message renders, each at its full path: a union whose
+ * selection leaves one branch failing below its root contributes that branch's
+ * issues under the union's path, recursively (#570), and every other union
+ * keeps its one issue at its own path — the value the union rejected, read as
+ * a whole — and is also read at each path below it where every branch listed
+ * the values it takes (#714, {@link everyBranchRefuses}). That is where a
+ * literal tag no branch takes sits, read as a plain field holding every
+ * branch's literal reads it: `"1"` against tags `1` and `2` reads as it does
+ * against `z.union([z.literal(1), z.literal(2)])`. A discriminated union's
+ * unmatched discriminator, which Zod reports with no branches, is read from
+ * the tags it lists the same way ({@link unmatchedDiscriminator}). Inside the
+ * lifted branch each kind repairs exactly as it would in a non-union field,
+ * with its own gate. Only one branch looks inside the value there: every other
+ * failed at its root or on one literal, and so rejects the value whatever it
+ * holds — except where that literal sits at the very path being repaired,
+ * which the entry carries as a rival, and the gate then reads the value as a
+ * plain union field of those branches (`6` beside a `z.literal(5)` branch
+ * stays a number, so it stays rejected). A branch that accepts a number at the
+ * path is reported by Zod as its own check (`too_big`), which no gate takes.
+ * Two branches failing below their roots are never lifted, so neither is read
+ * below its root but where each lists the values it takes.
  *
  * **One pass, no stacking.** Only a value the first parse rejected is repaired,
- * and at most once, so a value one repair produced is never repaired again — an
- * integer inside a stringified array, a stringified field inside a stringified
- * object. The caller re-parses once.
+ * and at most once — the first issue at a path that yields a repair claims it —
+ * so a value one repair produced is never repaired again: an integer inside a
+ * stringified array, a stringified field inside a stringified object. The
+ * caller re-parses once. A repaired discriminator selects a variant Zod never
+ * parsed, so a second slip inside that variant is not repaired with it: the
+ * rejection reports it, the tag's repair held (#706).
  *
  * `JSON.parse` is the exact inverse of the `JSON.stringify` that produced a
  * string, and `String(n)` of a safe integer is the digits the caller sent, so
@@ -235,9 +397,130 @@ export declare function prevalidateAliasFirst(def: AnyToolDefinition, args: unkn
  * after validation has already failed and keeps the result only when it then
  * passes.
  *
+ * **A string is read as another type only where the field types it itself.**
+ * A field routed through a `.transform()`, `.pipe()`, or `z.preprocess()`
+ * can reject its transform's output rather than the string sent — `"15"` an
+ * ID-or-name lookup does not know — so a string there is never turned into a
+ * number, boolean, or one-element list. Nor is one at a path that could land on
+ * such a field ({@link routesThroughPipeAt}): one option of a plain union
+ * declaring it while another declares or catches the same key, one side of an
+ * intersection, or an option whose own tag the caller sent wrong — the tag
+ * itself included, so `"1"` stays a string where one branch types its tag
+ * through a `z.preprocess()`.
+ *
+ * **A value inside a transform's output (#599).** Below a `z.preprocess()` or
+ * a `.transform().pipe()`, an issue path runs through what the transform made
+ * of the argument — `items.0.year` inside the list a preprocess wrapped a lone
+ * object in — so each path is read through {@link argumentAt}, which re-applies
+ * the transform in-process. The repair is written into that output, and the
+ * output is put in the argument's place only when the transform, applied to
+ * it, returns it structurally unchanged ({@link applyRepairs}); a transform
+ * that would reorder it, rewrite a value in it, or reject it leaves the
+ * argument as sent. The field the value sits in still decides the string
+ * kinds: a plain `z.string()` inside a wrapped list takes them, a field that
+ * is itself a pipe does not.
+ *
+ * **The same values written in place, tried first.** A repair can also be read
+ * and written at its issue path in the arguments as sent, leaving the re-parse
+ * to run the transform over it again. That validates calls the substitution
+ * refuses — `[1, 2]` under a preprocess that reverses a list reaches the
+ * handler as `["2", "1"]` — and gives some a different value: `[5]` under one
+ * that doubles numbers reaches it as `["5"]`, where the substitution would
+ * hand on `["10"]`. The original repair ({@link repairAsSent}) already places
+ * every value Zod's own issues name that way, so each call it validated keeps
+ * its value; `inPlace` carries the placement where that repair does not reach
+ * — inside a union's one surviving branch, and beside this pass's other
+ * repairs — so such a call gets the value the field gets on its own. It is
+ * built whenever a value below a transform, or behind one that throws when
+ * re-applied, is repairable that way, with the kinds that placement carries: a
+ * stringified array or object, and an integer sent for a string.
+ * {@link parseToolArguments} parses it after the original repair and before
+ * `args`, and keeps it when it validates. Each repair of `original` that no
+ * rendered issue reaches and that sits at no transform — a union field's
+ * value read whole, a stringified list beside a branch that splits a string —
+ * joins `repairs` too ({@link withOriginal}), so a call needing it beside a
+ * repair only this pass makes validates, and a rejection reports it as held.
+ * The repairs without it come back as `unaided`, parsed when `args` fails:
+ * integers inside the list a branch decodes from JSON text need the lifted
+ * branch's repairs, and the original reading of the text refuses them.
+ *
+ * Every value is read beside the caller's arguments, each transform at most
+ * once per value through `transforms`, and the repairs found are written in
+ * one {@link applyRepairs} pass per placement, so the work is linear in the
+ * issues however many values one array holds. They come back as `repairs`,
+ * one per path.
+ *
  * `args` is 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: readonly ArgumentIssue[]): RepairedArguments;
+export declare function repairRepresentations(args: unknown, issues: readonly LocatedIssue[], input: ToolInputSchema, transforms: TransformCache, original?: readonly Repair[]): RepairedArguments;
+/**
+ * The repair 0.13.13 and earlier made, which every call it validated must
+ * still get first: each of the failed parse's own issues at a non-root path,
+ * read and written at that path in the arguments as sent
+ * ({@link inPlaceRepair}). A value takes one kind of those repairs whichever
+ * issue names it, and {@link applyRepairs} writes a path two repairs share
+ * once. Zod's own list, not the one the rejection renders: a union whose
+ * selection lifts a branch (#570) is read here as the one value it rejected,
+ * so a stringified list for a field whose other branch splits or wraps a
+ * string parses back into the list, as that reading gave it. `undefined` when
+ * nothing repairs.
+ */
+export declare function repairAsSent(args: unknown, issues: readonly ArgumentIssue[]): {
+    readonly args: unknown;
+    readonly kinds: readonly CoercionKind[];
+    readonly repairs: readonly Repair[];
+} | undefined;
+/**
+ * Writes `repairs` onto `args`, copying each container on their paths once and
+ * leaving the caller's own objects untouched — so a thousand repaired elements
+ * of one array cost one copy of it, not a thousand. A `null_as_absent` repair
+ * leaves its key out of the copy of the object that holds it. A path two
+ * repairs share takes the first. Any subset of one call's
+ * {@link RepairedArguments.repairs} can be written, which is how
+ * {@link parseToolArguments} builds a rejection from the repairs that held.
+ *
+ * A repair inside a transform's output (#599) is written into that output, and
+ * the output takes the argument's place only when the transform, applied to
+ * it, returns it unchanged — compared structurally, since a transform may
+ * rebuild the list it was handed. That is the one check the validity re-parse
+ * cannot make: a transform that reorders or rewrites its input could validate
+ * with values the repair never wrote. Otherwise every repair inside that
+ * output is dropped and the argument is left as sent, so the call keeps its
+ * rejection. A transform that throws on the output counts as one that changed
+ * it. Nested transforms are checked at each position, innermost first.
+ *
+ * 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, so no key is
+ * added or renamed, and none is dropped but a deleted one.
+ */
+export declare function applyRepairs(args: unknown, repairs: readonly Repair[]): unknown;
+/**
+ * The repairs a failed re-parse kept (#706): each one no issue of `issues` lies
+ * at or below — the re-parse accepted the value it wrote, and whatever still
+ * fails is somewhere else. A union's issue counts at its own path and every
+ * branch's issues at theirs, whichever branch the rendering would select: a
+ * repair one branch accepts and another refuses at the same path did not hold,
+ * because the repaired value is what the refusing branch would then report.
+ *
+ * Each issue walks the tree of repair paths along its own path, so the check
+ * is linear in the issues and the repairs together, however many of each one
+ * array carries. An issue is walked from a node once (#648): Zod hands every
+ * branch that parsed the same value the same issue objects, so a recursive
+ * union whose `and` and `or` branches share a clause lists it under both, and
+ * walking each listing would double the walk per level of the caller's
+ * nesting.
+ */
+export declare function heldRepairs(repairs: readonly Repair[], issues: readonly ArgumentIssue[]): readonly Repair[];
+/**
+ * Structural equality over what arguments are made of: the same value, or
+ * arrays and plain objects holding equal entries under the same keys. Any
+ * other object equals only itself.
+ */
+export declare function sameValue(a: unknown, b: unknown): boolean;
 export {};
 //# sourceMappingURL=inputPrevalidation.d.ts.map

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

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