@zackbart/connecta 0.38.0 → 0.40.0

package/dist/validate.js

@@ -1,5 +1,6 @@
 import { Validator } from "@cfworker/json-schema";
-import { boundedEchoText, ConnectorCallError } from "./errors.js";
+import { redactCallArguments } from "./argument-redaction.js";
+import { boundedEchoText, boundText, ConnectorCallError, issueSummary, listed } from "./errors.js";
 import { MAX_ARGUMENT_VALIDATION_ISSUES } from "./errors.js";
 import { failureRecord, logFailure } from "./operator-record.js";
 // Lazy validator cache keyed by the schema object itself; null marks a schema
@@ -9,6 +10,7 @@ import { failureRecord, logFailure } from "./operator-record.js";
 const validators = new WeakMap();
 const evaluationWarnings = new WeakSet();
 const REQUIRED_PROPERTY_RE = /^Instance does not have required property "([^"]+)"\.$/;
+const DEPENDENT_PROPERTY_RE = /^Instance has "([^"]+)" but does not have "([^"]+)"\.$/;
 function plainContainer(value) {
     if (value === null || typeof value !== "object")
         return false;
@@ -94,11 +96,6 @@ function pointerValue(value, pointer) {
     }
     return current;
 }
-function argumentPath(location) {
-    if (location === "#")
-        return "/";
-    return location.startsWith("#") ? location.slice(1) || "/" : "/";
-}
 function validationUnitKey(unit) {
     return JSON.stringify([unit.keyword, unit.keywordLocation, unit.instanceLocation, unit.error]);
 }
@@ -153,17 +150,24 @@ function isDuplicateAdditionalPropertiesBranch(schema, units, index) {
 }
 function normalizedValidationUnits(schema, units) {
     const seen = new Set();
-    return units.filter((unit, index) => {
+    return units.flatMap((unit, index) => {
         if (CONTAINER_VALIDATION_KEYWORDS.has(unit.keyword))
-            return false;
+            return [];
         if (isDuplicateAdditionalPropertiesBranch(schema, units, index)) {
-            return false;
+            return [];
         }
         const key = validationUnitKey(unit);
         if (seen.has(key))
-            return false;
+            return [];
         seen.add(key);
-        return true;
+        // The validator locates a false subschema by instance; its wrapper names the object.
+        const wrapper = units[index - 1];
+        return unit.keyword === "false" &&
+            wrapper?.keyword === "additionalProperties" &&
+            wrapper.keywordLocation.endsWith("/additionalProperties") &&
+            childPropertyName(wrapper.instanceLocation, unit.instanceLocation) !== undefined
+            ? [{ ...unit, closedBy: wrapper.keywordLocation.slice(0, -"/additionalProperties".length) || "#" }]
+            : [unit];
     });
 }
 const JSON_TYPES = new Set(["string", "number", "integer", "boolean", "object", "array", "null"]);
@@ -176,70 +180,17 @@ function declaredType(value) {
         ? types.join(" | ")
         : undefined;
 }
-function expectedType(schema, unit) {
-    if (unit.keyword === "type") {
-        return declaredType(pointerValue(schema, unit.keywordLocation));
-    }
-    if (unit.keyword === "required") {
-        const missing = REQUIRED_PROPERTY_RE.exec(unit.error)?.[1];
-        if (!missing)
-            return undefined;
-        const parentLocation = unit.keywordLocation.replace(/\/required$/, "");
-        return (declaredType(pointerValue(schema, `${parentLocation}/properties/${encodePointerPart(missing)}/type`)) ?? "present");
-    }
-    const fixed = {
-        additionalProperties: "no additional properties",
-        enum: "one of the declared values",
-        const: "the declared constant",
-        minLength: "the declared minimum length",
-        maxLength: "the declared maximum length",
-        minimum: "the declared minimum",
-        maximum: "the declared maximum",
-        pattern: "the declared string pattern",
-    };
-    return fixed[unit.keyword];
-}
-function validationDetails(schema, units) {
-    const issues = [];
-    for (const unit of units) {
-        const missing = unit.keyword === "required" ? REQUIRED_PROPERTY_RE.exec(unit.error)?.[1] : undefined;
-        const path = missing !== undefined
-            ? `${argumentPath(unit.instanceLocation).replace(/\/$/, "")}/${encodePointerPart(missing)}`
-            : argumentPath(unit.instanceLocation);
-        const code = unit.keyword === "false" ? "additionalProperties" : unit.keyword;
-        const expected = expectedType(schema, unit) ??
-            (code === "additionalProperties" ? "no additional properties" : "the declared schema constraint");
-        const issue = { path, code, expected };
-        if (!issues.some((existing) => existing.path === issue.path && existing.code === issue.code && existing.expected === issue.expected)) {
-            issues.push(issue);
-        }
-    }
-    return {
-        issues: issues.slice(0, MAX_ARGUMENT_VALIDATION_ISSUES),
-        ...(issues.length > MAX_ARGUMENT_VALIDATION_ISSUES ? { truncated: true } : {}),
-    };
-}
 function schemaObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function receivedType(value) {
     return value === undefined ? "missing" : value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
 }
-const BOUND_KEYWORDS = [
-    "minimum",
-    "maximum",
-    "exclusiveMinimum",
-    "exclusiveMaximum",
-    "multipleOf",
-    "minLength",
-    "maxLength",
-    "minItems",
-    "maxItems",
-    "minProperties",
-    "maxProperties",
-];
-/** No caller values are used to invent an example. A candidate must validate. */
-function exampleCandidate(schema, root, depth = 0, budget = { remaining: 128, active: new Set() }) {
+/**
+ * No caller values are used to invent an example, and a writeOnly position or
+ * anything inside one never renders a schema literal. A candidate must validate.
+ */
+function exampleCandidate(schema, root, depth = 0, budget = { remaining: 128, active: new Set() }, secret = false) {
     if (--budget.remaining < 0)
         throw new Error("Example synthesis budget exhausted");
     if (depth > 12 || schema === false)
@@ -248,22 +199,23 @@ function exampleCandidate(schema, root, depth = 0, budget = { remaining: 128, ac
     if (budget.active.has(node))
         throw new Error("Recursive schema cannot produce a bounded example");
     budget.active.add(node);
+    secret ||= node.writeOnly === true;
     try {
         if (typeof node.$ref === "string") {
-            return exampleCandidate(pointerValue(root, node.$ref), root, depth + 1, budget);
+            return exampleCandidate(pointerValue(root, node.$ref), root, depth + 1, budget, secret);
         }
-        if (Object.hasOwn(node, "const"))
+        if (!secret && Object.hasOwn(node, "const"))
             return node.const;
-        if (Array.isArray(node.enum))
+        if (!secret && Array.isArray(node.enum))
             return node.enum[0];
         const type = Array.isArray(node.type) ? node.type[0] : node.type;
         const variants = Array.isArray(node.oneOf) ? node.oneOf : node.anyOf;
         if (Array.isArray(variants) && variants.length) {
-            return mergeExample(exampleCandidate({ ...node, oneOf: undefined, anyOf: undefined }, root, depth + 1, budget), exampleCandidate(variants[0], root, depth + 1, budget));
+            return mergeExample(exampleCandidate({ ...node, oneOf: undefined, anyOf: undefined }, root, depth + 1, budget, secret), exampleCandidate(variants[0], root, depth + 1, budget, secret));
         }
-        if (Array.isArray(node.examples) && node.examples.length)
+        if (!secret && Array.isArray(node.examples) && node.examples.length)
             return node.examples[0];
-        if (Object.hasOwn(node, "default"))
+        if (!secret && Object.hasOwn(node, "default"))
             return node.default;
         let candidate;
         if (type === "object" || node.properties || node.required || node.allOf) {
@@ -272,10 +224,10 @@ function exampleCandidate(schema, root, depth = 0, budget = { remaining: 128, ac
             candidate = Object.fromEntries(required
                 .filter((key) => typeof key === "string")
                 .slice(0, 30)
-                .map((key) => [key, exampleCandidate(properties[key], root, depth + 1, budget)]));
+                .map((key) => [key, exampleCandidate(properties[key], root, depth + 1, budget, secret)]));
             if (Array.isArray(node.allOf)) {
                 for (const branch of node.allOf.slice(0, 20)) {
-                    candidate = mergeExample(candidate, exampleCandidate(branch, root, depth + 1, budget));
+                    candidate = mergeExample(candidate, exampleCandidate(branch, root, depth + 1, budget, secret));
                 }
             }
             const object = schemaObject(candidate);
@@ -285,7 +237,7 @@ function exampleCandidate(schema, root, depth = 0, budget = { remaining: 128, ac
                     for (const need of needs.slice(0, 30)) {
                         if (typeof need === "string" && !Object.hasOwn(object, need)) {
                             Object.defineProperty(object, need, {
-                                value: exampleCandidate(properties[need], root, depth + 1, budget),
+                                value: exampleCandidate(properties[need], root, depth + 1, budget, secret),
                                 enumerable: true,
                                 configurable: true,
                                 writable: true,
@@ -297,7 +249,7 @@ function exampleCandidate(schema, root, depth = 0, budget = { remaining: 128, ac
             if (node.if) {
                 try {
                     const matches = new Validator(node.if, "2020-12", false).validate(candidate).valid;
-                    candidate = mergeExample(candidate, exampleCandidate(matches ? node.then : node.else, root, depth + 1, budget));
+                    candidate = mergeExample(candidate, exampleCandidate(matches ? node.then : node.else, root, depth + 1, budget, secret));
                 }
                 catch {
                     // An unevaluable branch cannot establish a valid example.
@@ -306,13 +258,13 @@ function exampleCandidate(schema, root, depth = 0, budget = { remaining: 128, ac
             // Branches may declare required keys while their types live on the parent.
             for (const key of Object.keys(schemaObject(candidate))) {
                 if (schemaObject(candidate)[key] === undefined) {
-                    schemaObject(candidate)[key] = exampleCandidate(properties[key], root, depth + 1, budget);
+                    schemaObject(candidate)[key] = exampleCandidate(properties[key], root, depth + 1, budget, secret);
                 }
             }
         }
         else if (type === "array") {
             const count = typeof node.minItems === "number" ? node.minItems : 0;
-            candidate = Array.from({ length: Math.min(count, 20) }, (_, index) => exampleCandidate(Array.isArray(node.prefixItems) ? node.prefixItems[index] : node.items, root, depth + 1, budget));
+            candidate = Array.from({ length: Math.min(count, 20) }, (_, index) => exampleCandidate(Array.isArray(node.prefixItems) ? node.prefixItems[index] : node.items, root, depth + 1, budget, secret));
         }
         else if (type === "number" || type === "integer") {
             let number = typeof node.minimum === "number" ? node.minimum : 0;
@@ -400,90 +352,203 @@ function minimizeExample(example, validator) {
     };
     visit(example, 0);
 }
-function repairDetails(schema, args, units, validator) {
-    const root = schemaObject(schema);
-    const keys = (node) => Object.entries(schemaObject(node.properties))
-        .filter(([, value]) => value !== false)
-        .map(([key]) => key);
-    const issues = units.slice(0, MAX_ARGUMENT_VALIDATION_ISSUES).map((unit) => {
-        const missing = unit.keyword === "required" ? REQUIRED_PROPERTY_RE.exec(unit.error)?.[1] : undefined;
-        const location = missing === undefined ? unit.instanceLocation : `${unit.instanceLocation}/${encodePointerPart(missing)}`;
-        const parentLocation = unit.keywordLocation.replace(/\/[^/]+$/, "");
-        const parent = schemaObject(pointerValue(schema, parentLocation));
-        const node = missing === undefined ? parent : schemaObject(schemaObject(parent.properties)[missing]);
-        const bounds = Object.fromEntries(BOUND_KEYWORDS.flatMap((key) => (typeof node[key] === "number" ? [[key, node[key]]] : [])));
-        // A false subschema under additionalProperties names its parent object's keys.
-        const closedParent = unit.keyword === "false" && unit.keywordLocation.endsWith("/additionalProperties")
-            ? schemaObject(pointerValue(schema, unit.keywordLocation.slice(0, -"/additionalProperties".length)))
-            : node;
-        const acceptedKeys = keys(closedParent);
+/** The JSON Pointer of the argument a unit names; a missing property gets its own path. */
+function unitLocation(unit) {
+    const dependent = DEPENDENT_PROPERTY_RE.exec(unit.error);
+    const missing = unit.keyword === "required" ? REQUIRED_PROPERTY_RE.exec(unit.error)?.[1] : dependent?.[2];
+    return missing === undefined
+        ? { location: unit.instanceLocation }
+        : {
+            location: `${unit.instanceLocation}/${encodePointerPart(missing)}`,
+            missing,
+            ...(dependent ? { with: dependent[1] } : {}),
+        };
+}
+/** A schema node with its local references followed. */
+function resolved(root, value) {
+    let node = schemaObject(value);
+    for (let hops = 0; typeof node.$ref === "string" && hops < 8; hops++)
+        node = schemaObject(pointerValue(root, node.$ref));
+    return node;
+}
+/**
+ * Where a finding may point, and whether that position is sensitive. A path
+ * names only properties the schema declares and array indices; the first
+ * other key reads `<key>` and ends it, since a map key is caller text. A
+ * position is sensitive when it or any ancestor is writeOnly.
+ */
+function publicPosition(root, location) {
+    let node = resolved(root, root);
+    let path = "";
+    let sensitive = node.writeOnly === true;
+    for (const part of location === "#" ? [] : location.slice(2).split("/").map(decodePointerPart)) {
+        const branches = [
+            node,
+            ...["allOf", "anyOf", "oneOf"].flatMap((key) => (Array.isArray(node[key]) ? node[key] : [])),
+        ].map((branch) => resolved(root, branch));
+        const owner = branches.find((branch) => Object.hasOwn(schemaObject(branch.properties), part));
+        const list = branches.find((branch) => branch.items !== undefined || Array.isArray(branch.prefixItems));
+        if (owner)
+            node = resolved(root, schemaObject(owner.properties)[part]);
+        else if (list && /^(?:0|[1-9]\d*)$/.test(part))
+            node = resolved(root, Array.isArray(list.prefixItems) ? (list.prefixItems[Number(part)] ?? list.items) : list.items);
+        else {
+            const values = branches.find((branch) => branch.additionalProperties !== undefined);
+            return {
+                path: `${path}/<key>`,
+                sensitive: sensitive || resolved(root, values?.additionalProperties).writeOnly === true,
+            };
+        }
+        sensitive ||= node.writeOnly === true;
+        path += `/${owner ? encodePointerPart(part) : part}`;
+    }
+    return { path: path || "/", sensitive };
+}
+const patternText = (pattern, sensitive) => `matching ${!sensitive && typeof pattern === "string" && pattern.length <= 64 ? pattern : "the inputSchema pattern"}`;
+/** Every other constraint a schema node declares, so one finding states them all; no literal of a sensitive one. */
+function constraints(node, failed, sensitive) {
+    return Object.keys(node).flatMap((key) => key === failed
+        ? []
+        : key === "enum" && Array.isArray(node.enum) && !sensitive
+            ? `one of ${listed(node.enum.map((item) => JSON.stringify(item)))}`
+            : key === "uniqueItems" && node.uniqueItems === true
+                ? "unique items"
+                : key === "pattern"
+                    ? patternText(node.pattern, sensitive)
+                    : key === "format"
+                        ? `${String(node.format)} format`
+                        : (boundText(key, node[key]) ?? []));
+}
+/**
+ * One finding per unit, told from the reviewed schema, never the validator's
+ * own sentences or a submitted string or key. A bound violation states the
+ * bound and, unless the position is sensitive, the submitted number. A
+ * sensitive position never renders a schema literal (enum, const, pattern).
+ */
+function issueFor(schema, args, safeArgs, unit) {
+    const { location, missing, with: present } = unitLocation(unit);
+    const position = publicPosition(schema, location);
+    const keyword = pointerValue(schema, unit.keywordLocation);
+    const parent = unit.keywordLocation.replace(/\/[^/]+$/, "");
+    const node = schemaObject(pointerValue(schema, missing === undefined ? parent : `${parent}/properties/${encodePointerPart(missing)}`));
+    const path = position.path;
+    // Unresolved sensitivity (no redacted copy) is treated as sensitive.
+    const sensitive = position.sensitive || node.writeOnly === true || safeArgs === undefined;
+    let received = receivedType(pointerValue(args, location));
+    let expected;
+    if (missing !== undefined) {
+        expected = `${declaredType(node.type) ?? "a value"} (required${present ? ` with ${present}` : ""})`;
+        received = "missing";
+    }
+    else if (unit.keyword === "false") {
+        // A false subschema under additionalProperties names its object's accepted keys.
+        if (unit.closedBy === undefined)
+            return { path, expected: "absent: the inputSchema forbids this value" };
+        const keys = Object.entries(schemaObject(schemaObject(pointerValue(schema, unit.closedBy)).properties))
+            .filter(([, child]) => child !== false)
+            .map(([key]) => key);
+        return { path, expected: keys.length ? `one of the accepted keys: ${listed(keys)}` : "no additional properties" };
+    }
+    else if (unit.keyword === "const") {
+        const constant = JSON.stringify(keyword);
         return {
-            path: argumentPath(location),
-            receivedType: receivedType(pointerValue(args, location)),
-            ...(acceptedKeys.length ? { acceptedKeys } : {}),
-            ...(Array.isArray(node.enum) ? { enumValues: node.enum } : {}),
-            ...(Object.keys(bounds).length ? { bounds } : {}),
+            path,
+            expected: !sensitive && constant?.length <= 64 ? `the constant ${constant}` : "the declared constant",
         };
+    }
+    else if (unit.keyword === "type")
+        expected = declaredType(keyword) ?? "the declared type";
+    else if (unit.keyword === "enum" && Array.isArray(keyword) && !sensitive)
+        expected = `one of ${listed(keyword.map((value) => JSON.stringify(value)))}`;
+    else if (unit.keyword === "uniqueItems")
+        expected = "unique items";
+    else if (unit.keyword === "pattern")
+        expected = `a string ${patternText(keyword, sensitive)}`;
+    else if (unit.keyword === "format")
+        expected = `a ${String(keyword)} string`;
+    else {
+        const bound = boundText(unit.keyword, keyword);
+        const safe = pointerValue(safeArgs, location);
+        if (bound && typeof safe === "number" && !sensitive)
+            received = String(safe);
+        expected = bound ?? "a value matching the published inputSchema";
+    }
+    return {
+        path,
+        expected: [expected, ...constraints(node, missing === undefined ? unit.keyword : "type", sensitive)].join(", "),
+        received,
+    };
+}
+/** Every unit as a merged finding, bounded and without duplicates. */
+function validationIssues(schema, args, units) {
+    // writeOnly positions are omitted; unresolved sensitivity withholds every value.
+    let safeArgs;
+    try {
+        safeArgs = redactCallArguments(args, schema).value;
+    }
+    catch {
+        safeArgs = undefined;
+    }
+    // One finding per schema position: each already states every constraint it declares.
+    const seen = new Set();
+    return units.flatMap((unit) => {
+        const issue = issueFor(schema, args, safeArgs, unit);
+        const key = `${issue.path}\n${unit.keywordLocation.replace(/\/[^/]+$/, "")}\n${unit.keyword === "false"}`;
+        return seen.has(key) ? [] : (seen.add(key), [issue]);
     });
+}
+/** One example synthesized from the published schema alone, checked by its validator; never caller values. */
+export function schemaExample(schema) {
+    try {
+        const validator = validators.get(schema) ?? new Validator(schema, "2020-12", false);
+        // Serialization makes the validation cover exactly what the agent receives.
+        const example = JSON.parse(JSON.stringify(exampleCandidate(schema, schema)));
+        if (validator.validate(example).valid) {
+            minimizeExample(example, validator);
+            if (validator.validate(example).valid)
+                return { example };
+        }
+    }
+    catch {
+        // Unsatisfiable or complex schemas do not get a made-up valid example.
+    }
+    return { exampleUnavailable: "No valid example could be synthesized. Inspect the published inputSchema." };
+}
+/** Names from the published schema and one synthesized example; no caller values and no schema conditions. */
+function schemaFacts(schema) {
+    const root = schemaObject(schema);
     const conditionalRequirements = [];
     const visit = (value, path, depth) => {
         if (depth > 12 || conditionalRequirements.length >= 20)
             return;
         const node = schemaObject(value);
-        for (const [key, required] of Object.entries(schemaObject(node.dependentRequired ?? node.dependencies))) {
-            if (Array.isArray(required) && required.every((key) => typeof key === "string")) {
-                conditionalRequirements.push({ path, condition: { required: [key] }, required });
-            }
-        }
-        for (const [key, branch] of Object.entries(schemaObject(node.dependentSchemas))) {
-            const required = schemaObject(branch).required;
+        for (const [key, required] of [
+            ...Object.entries(schemaObject(node.dependentRequired ?? node.dependencies)),
+            ...Object.entries(schemaObject(node.dependentSchemas)).map(([key, branch]) => [
+                key,
+                schemaObject(branch).required,
+            ]),
+        ]) {
             if (Array.isArray(required) && required.every((key) => typeof key === "string")) {
                 conditionalRequirements.push({ path, condition: { required: [key] }, required });
             }
         }
-        for (const [branch, condition] of [
-            [node.then, node.if],
-            [node.else, node.if ? { not: node.if } : undefined],
-        ]) {
-            const required = schemaObject(branch).required;
-            if (condition && Array.isArray(required) && required.every((key) => typeof key === "string")) {
-                conditionalRequirements.push({ path, condition, required });
-            }
-        }
         for (const [key, child] of Object.entries(schemaObject(node.properties)))
             visit(child, `${path === "/" ? "" : path}/${encodePointerPart(key)}`, depth + 1);
         // Alternatives can make a dependency branch-specific. Do not state its
         // requirements without proving the complete branch condition.
-        for (const key of ["allOf"]) {
-            if (Array.isArray(node[key]))
-                for (const child of node[key])
-                    visit(child, path, depth + 1);
-        }
+        if (Array.isArray(node.allOf))
+            for (const child of node.allOf)
+                visit(child, path, depth + 1);
     };
     visit(schema, "/", 0);
-    let example;
-    let valid = false;
-    try {
-        // Serialization makes the validation cover exactly what the agent receives.
-        example = JSON.parse(JSON.stringify(exampleCandidate(schema, schema)));
-        valid = validator.validate(example).valid;
-        if (valid) {
-            minimizeExample(example, validator);
-            valid = validator.validate(example).valid;
-        }
-    }
-    catch {
-        valid = false;
-        // Unsatisfiable or complex schemas do not get a made-up valid example.
-    }
+    const keys = Object.entries(schemaObject(root.properties))
+        .filter(([, value]) => value !== false)
+        .map(([key]) => key);
     return {
-        ...(root.properties ? { acceptedKeys: keys(root) } : {}),
-        issues,
+        ...(root.properties ? { acceptedKeys: keys } : {}),
         ...(conditionalRequirements.length ? { conditionalRequirements } : {}),
-        ...(valid
-            ? { example }
-            : { exampleUnavailable: "No valid example could be synthesized. Inspect the published inputSchema." }),
-        ...(units.length > MAX_ARGUMENT_VALIDATION_ISSUES ? { truncated: true } : {}),
+        ...schemaExample(schema),
     };
 }
 function unevaluableSchema(address) {
@@ -572,10 +637,11 @@ export function validateCatalogToolInput(schema, args, opts, subject) {
     }
     if (result && !result.valid) {
         const units = normalizedValidationUnits(schema, result.errors);
-        const nestedUnits = units.filter((unit) => unit.instanceLocation !== "#");
-        // Told from the reviewed findings, never the validator's own sentences,
-        // which quote the schema's types, enums, and patterns.
-        const validation = validationDetails(schema, units);
+        const nested = (unit) => unit.instanceLocation !== "#" || unitLocation(unit).missing !== undefined;
+        // A root-level finding often restates a nested one (an alternative that
+        // did not match), so nested findings lead and the message names only them.
+        const issues = validationIssues(schema, args, [...units.filter(nested), ...units.filter((unit) => !nested(unit))]);
+        const named = issues.some((issue) => issue.path !== "/") ? issues.filter((issue) => issue.path !== "/") : issues;
         const limit = schema.properties?.limit?.enum;
         const supplied = args !== null && typeof args === "object" ? args["limit"] : undefined;
         const discreteLimit = supplied !== undefined &&
@@ -584,16 +650,12 @@ export function validateCatalogToolInput(schema, args, opts, subject) {
             limit.length <= 8 &&
             limit.every((size) => Number.isSafeInteger(size) && Number(size) > 0) &&
             !limit.includes(supplied);
-        const otherUnits = units.filter((unit) => unit.instanceLocation !== "#/limit");
-        const otherIssues = otherUnits.length > 0;
-        const shown = discreteLimit
-            ? validationDetails(schema, otherUnits)
-            : nestedUnits.length > 0
-                ? validationDetails(schema, nestedUnits)
-                : validation;
-        const detail = boundedEchoText(shown.issues.map((issue) => `${issue.path}: expected ${issue.expected} (${issue.code})`).join("; "), 256);
+        const shown = discreteLimit ? named.filter((issue) => issue.path !== "/limit") : named;
+        const detail = boundedEchoText(issueSummary(shown.slice(0, MAX_ARGUMENT_VALIDATION_ISSUES)), 512);
         const ordinary = `Invalid arguments for "${opts.address}": ${detail || "input does not match the tool's inputSchema"}`;
-        return new ConnectorCallError("invalid_args", discreteLimit ? `The limit must be one of ${limit.join(", ")}.${otherIssues ? ` ${ordinary}` : ""}` : ordinary, { validation, repair: repairDetails(schema, args, units, validator) });
+        return new ConnectorCallError("invalid_args", discreteLimit ? `The limit must be one of ${limit.join(", ")}.${shown.length ? ` ${ordinary}` : ""}` : ordinary, {
+            validation: { issues, ...schemaFacts(schema) },
+        });
     }
     return null;
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CONNECTA_VERSION = "0.38.0";
+export declare const CONNECTA_VERSION = "0.40.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated from package.json by scripts/generate-version.mjs.
 // Workers-safe: no runtime filesystem read or deployment override.
-export const CONNECTA_VERSION = "0.38.0";
+export const CONNECTA_VERSION = "0.40.0";

package/dist/write-outcome.js

@@ -332,7 +332,6 @@ function withoutRetry(error) {
         writeOutcome: "unknown",
         ...(error.details ? { details: error.details } : {}),
         ...(error.validation ? { validation: error.validation } : {}),
-        ...(error.repair ? { repair: error.repair } : {}),
         ...(error.current ? { current: error.current } : {}),
     }));
 }
@@ -376,7 +375,6 @@ export function providerFailureMessage(error, message) {
         ...(error.retryAfterMs === undefined ? {} : { retryAfterMs: error.retryAfterMs }),
         ...(error.details ? { details: error.details } : {}),
         ...(error.validation ? { validation: error.validation } : {}),
-        ...(error.repair ? { repair: error.repair } : {}),
         ...(error.current ? { current: error.current } : {}),
     }));
 }
@@ -412,7 +410,6 @@ function uncertainProviderFailure(vendor, error, ctx) {
             ? {
                 ...(error.retryAfterMs === undefined ? {} : { retryAfterMs: error.retryAfterMs }),
                 ...(error.validation ? { validation: error.validation } : {}),
-                ...(error.repair ? { repair: error.repair } : {}),
                 ...(error.current ? { current: error.current } : {}),
             }
             : {}),

package/documentation/README.md

@@ -8,19 +8,19 @@ For a new deployment, start with [Deploying Connecta](./deploying.md).
 
 ## Operator tasks
 
-| Task                                             | Self-contained procedure                                                                                                            |
-| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
-| Add or remove a connector                        | [Change the connector roster](./integrating.md#add-or-remove-a-connector)                                                           |
-| Set up a maintained provider                     | [Maintained provider setup](./providers.md)                                                                                         |
-| Inspect maintained API sources and tools         | [API sources and tool inventory](./providers.md#api-sources-and-tool-inventory)                                                     |
-| Organize an agent's pools and tiers              | [Organizing an agent's pools](./auth.md#organizing-an-agents-pools)                                                                 |
-| Add a person (maintainer or pool member)         | [Add a person](./auth.md#add-a-person), [member page](./operator-ui.md#use-the-member-page)                                         |
-| Connect Google hosted MCP with a service account | [Google tokens and shared-agent/personal-people setup](./auth.md#google-service-account-tokens-and-hosted-mcp)                      |
-| Connect a shared credential                      | [Connect a shared credential](./auth.md#connect-a-shared-credential)                                                                |
-| Issue, rotate, or revoke an agent token          | [Manage an agent token](./auth.md#issue-rotate-or-revoke-an-agent-token)                                                            |
-| Upgrade between versions                         | [Upgrade an existing deployment](./deploying.md#upgrade-an-existing-deployment), including [migration to 0.33](./migration-0.33.md) |
-| Diagnose with `connecta doctor`                  | [Verify and diagnose](./deploying.md#verify-and-diagnose)                                                                           |
-| Connect a client with tool search                | [Native tool surface](./meta-tools.md#native-tool-surface), [Eve agents](./meta-tools.md#eve-agents)                                |
+| Task                                             | Self-contained procedure                                                                                                                                                                      |
+| ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Add or remove a connector                        | [Change the connector roster](./integrating.md#add-or-remove-a-connector)                                                                                                                     |
+| Set up a maintained provider                     | [Maintained provider setup](./providers.md)                                                                                                                                                   |
+| Inspect maintained API sources and tools         | [API sources and tool inventory](./providers.md#api-sources-and-tool-inventory)                                                                                                               |
+| Organize an agent's pools and tiers              | [Organizing an agent's pools](./auth.md#organizing-an-agents-pools)                                                                                                                           |
+| Add a person (maintainer or pool member)         | [Add a person](./auth.md#add-a-person), [member page](./operator-ui.md#use-the-member-page)                                                                                                   |
+| Connect Google hosted MCP with a service account | [Google tokens and shared-agent/personal-people setup](./auth.md#google-service-account-tokens-and-hosted-mcp)                                                                                |
+| Connect a shared credential                      | [Connect a shared credential](./auth.md#connect-a-shared-credential)                                                                                                                          |
+| Issue, rotate, or revoke an agent token          | [Manage an agent token](./auth.md#issue-rotate-or-revoke-an-agent-token)                                                                                                                      |
+| Upgrade between versions                         | [Upgrade an existing deployment](./deploying.md#upgrade-an-existing-deployment), including [splitting mixed pools](./pool-membership-upgrade.md) and [migration to 0.33](./migration-0.33.md) |
+| Diagnose with `connecta doctor`                  | [Verify and diagnose](./deploying.md#verify-and-diagnose)                                                                                                                                     |
+| Connect a client with tool search                | [Native tool surface](./meta-tools.md#native-tool-surface), [Eve agents](./meta-tools.md#eve-agents)                                                                                          |
 
 For removed hosted presets and the former hosted modes of Stripe, Vercel,
 Cloudflare, and GitHub, use [Migrate hosted MCP presets](./hosted-mcp-migration.md).