attention-manifest-protocol 0.4.2 → 0.4.4

package/lib/boundary/toolCall.js

@@ -1,6 +1,308 @@
 import { canonical, digestOf } from "../semantic/canonical.js";
+import { cloneJson, deepFreezeJson, jsonValueProblem } from "../semantic/jsonValue.js";
+import { isDateTime } from "../semantic/time.js";
 import { BoundaryRejection } from "../error/boundaryRejection.js";
-const isRecord = (value) => typeof (value) === "object" && value !== null && !Array.isArray(value);
+/**
+ * Deepest schema/value walk; a `$ref` cycle and an absurdly nested schema both
+ * stop here with a schema problem instead of exhausting the stack.
+ */
+const MaxSchemaDepth = 128;
+const JsonTypes = ["null", "boolean", "object", "array", "string", "number", "integer"];
+/**
+ * Keywords that carry no constraint; their value is never interpreted.
+ */
+const AnnotationKeywords = [
+    "$schema",
+    "$id",
+    "title",
+    "description",
+    "default",
+    "examples",
+    "deprecated",
+    "readOnly",
+    "writeOnly",
+    "$comment",
+    "$defs",
+    "definitions",
+];
+/**
+ * Applicators this validator understands. Anything else is fail-closed.
+ */
+const SupportedKeywords = [
+    "$ref",
+    "type",
+    "const",
+    "enum",
+    "allOf",
+    "anyOf",
+    "oneOf",
+    "properties",
+    "required",
+    "additionalProperties",
+    "minProperties",
+    "maxProperties",
+    "dependentRequired",
+    "propertyNames",
+    "items",
+    "additionalItems",
+    "minItems",
+    "maxItems",
+    "uniqueItems",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "format",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+];
+const SupportedFormats = ["date-time", "date", "time", "email", "uri", "uuid"];
+const DatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+const TimePattern = /^(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:\d{2})$/;
+const EmailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const UriPattern = /^[A-Za-z][A-Za-z0-9+.-]*:\S*$/;
+const UuidPattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+const isPlainObject = (value) => {
+    if (typeof (value) !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    let prototype;
+    try {
+        prototype = Object.getPrototypeOf(value);
+    }
+    catch {
+        return false;
+    }
+    return prototype === null || prototype === Object.prototype;
+};
+const isSchemaNode = (value) => typeof (value) === "boolean" || isPlainObject(value);
+const readString = (schema, keyword, at, problems) => {
+    if (!Object.hasOwn(schema, keyword)) {
+        return (void 0);
+    }
+    const value = schema[keyword];
+    if (typeof (value) !== "string") {
+        problems.push(`${at}: "${keyword}" must be a string`);
+        return (void 0);
+    }
+    return value;
+};
+const readFiniteNumber = (schema, keyword, at, problems) => {
+    if (!Object.hasOwn(schema, keyword)) {
+        return (void 0);
+    }
+    const value = schema[keyword];
+    if (typeof (value) !== "number" || !Number.isFinite(value)) {
+        problems.push(`${at}: "${keyword}" must be a finite number`);
+        return (void 0);
+    }
+    return value;
+};
+const readCount = (schema, keyword, at, problems) => {
+    if (!Object.hasOwn(schema, keyword)) {
+        return (void 0);
+    }
+    const value = schema[keyword];
+    if (typeof (value) !== "number" || !Number.isInteger(value) || value < 0) {
+        problems.push(`${at}: "${keyword}" must be a non-negative integer`);
+        return (void 0);
+    }
+    return value;
+};
+const readBoolean = (schema, keyword, at, problems) => {
+    if (!Object.hasOwn(schema, keyword)) {
+        return (void 0);
+    }
+    const value = schema[keyword];
+    if (typeof (value) !== "boolean") {
+        problems.push(`${at}: "${keyword}" must be a boolean`);
+        return (void 0);
+    }
+    return value;
+};
+const readPlainObject = (schema, keyword, at, problems) => {
+    if (!Object.hasOwn(schema, keyword)) {
+        return (void 0);
+    }
+    const value = schema[keyword];
+    if (!isPlainObject(value)) {
+        problems.push(`${at}: "${keyword}" must be an object`);
+        return (void 0);
+    }
+    return value;
+};
+const readStringArray = (schema, keyword, at, problems) => {
+    if (!Object.hasOwn(schema, keyword)) {
+        return (void 0);
+    }
+    const value = schema[keyword];
+    if (!Array.isArray(value)) {
+        problems.push(`${at}: "${keyword}" must be an array of strings`);
+        return (void 0);
+    }
+    let valid = true;
+    for (let index = 0; index < value.length; index += 1) {
+        if (typeof (value[index]) !== "string") {
+            problems.push(`${at}: "${keyword}[${index}]" must be a string`);
+            valid = false;
+        }
+    }
+    if (!valid) {
+        return (void 0);
+    }
+    return value;
+};
+const readSchemaArray = (schema, keyword, at, problems) => {
+    if (!Object.hasOwn(schema, keyword)) {
+        return (void 0);
+    }
+    const value = schema[keyword];
+    if (!Array.isArray(value) || value.length === 0) {
+        problems.push(`${at}: "${keyword}" must be a non-empty array of schemas`);
+        return (void 0);
+    }
+    let valid = true;
+    for (let index = 0; index < value.length; index += 1) {
+        if (!isSchemaNode(value[index])) {
+            problems.push(`${at}: "${keyword}[${index}]" must be a schema`);
+            valid = false;
+        }
+    }
+    if (!valid) {
+        return (void 0);
+    }
+    return value;
+};
+const readEnum = (schema, at, problems) => {
+    if (!Object.hasOwn(schema, "enum")) {
+        return (void 0);
+    }
+    const declared = schema.enum;
+    if (!Array.isArray(declared) || declared.length === 0) {
+        problems.push(`${at}: "enum" must be a non-empty array of JSON values`);
+        return (void 0);
+    }
+    let valid = true;
+    for (let index = 0; index < declared.length; index += 1) {
+        const itemProblem = jsonValueProblem(declared[index], `${at}.enum[${index}]`);
+        if (itemProblem !== (void 0)) {
+            problems.push(`${at}: "enum[${index}]" is not JSON (${itemProblem})`);
+            valid = false;
+        }
+    }
+    if (!valid) {
+        return (void 0);
+    }
+    return declared;
+};
+const readTypes = (schema, at, problems) => {
+    if (!Object.hasOwn(schema, "type")) {
+        return (void 0);
+    }
+    const declared = schema.type;
+    const types = [];
+    let valid = true;
+    if (typeof (declared) === "string") {
+        types.push(declared);
+    }
+    else if (Array.isArray(declared)) {
+        if (declared.length === 0) {
+            problems.push(`${at}: "type" must not be an empty array`);
+            valid = false;
+        }
+        for (let index = 0; index < declared.length; index += 1) {
+            const item = declared[index];
+            if (typeof (item) !== "string") {
+                problems.push(`${at}: "type[${index}]" must be a string`);
+                valid = false;
+            }
+            else {
+                types.push(item);
+            }
+        }
+    }
+    else {
+        problems.push(`${at}: "type" must be a string or an array of strings`);
+        return (void 0);
+    }
+    for (let index = 0; index < types.length; index += 1) {
+        if (!JsonTypes.includes(types[index])) {
+            problems.push(`${at}: unknown type "${types[index]}"`);
+            valid = false;
+        }
+    }
+    if (!valid) {
+        return (void 0);
+    }
+    return types;
+};
+const sameJson = (left, right) => canonical(left) === canonical(right);
+const daysInMonth = (year, month) => {
+    if (month === 2) {
+        const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+        return leap ? 29 : 28;
+    }
+    return [4, 6, 9, 11].includes(month) ? 30 : 31;
+};
+const isDate = (value) => {
+    const match = DatePattern.exec(value);
+    if (match === null) {
+        return false;
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (month < 1 || month > 12) {
+        return false;
+    }
+    return day >= 1 && day <= daysInMonth(year, month);
+};
+const isTime = (value) => {
+    const match = TimePattern.exec(value);
+    if (match === null) {
+        return false;
+    }
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    const second = Number(match[3]);
+    if (hour > 23 || minute > 59 || second > 60) {
+        return false;
+    }
+    if (second === 60 && (hour !== 23 || minute !== 59)) {
+        return false;
+    }
+    if (match[5] !== "Z") {
+        const offsetHour = Number(match[5].slice(1, 3));
+        const offsetMinute = Number(match[5].slice(4, 6));
+        if (offsetHour > 23 || offsetMinute > 59) {
+            return false;
+        }
+    }
+    return true;
+};
+const formatMatches = (format, value) => {
+    if (format === "date-time") {
+        return isDateTime(value);
+    }
+    if (format === "date") {
+        return isDate(value);
+    }
+    if (format === "time") {
+        return isTime(value);
+    }
+    if (format === "email") {
+        return EmailPattern.test(value);
+    }
+    if (format === "uri") {
+        return UriPattern.test(value);
+    }
+    if (format === "uuid") {
+        return UuidPattern.test(value);
+    }
+    return false;
+};
 const matchesType = (type, value) => {
     if (type === "null") {
         return value === null;
@@ -9,7 +311,7 @@ const matchesType = (type, value) => {
         return Array.isArray(value);
     }
     if (type === "object") {
-        return isRecord(value);
+        return isPlainObject(value);
     }
     if (type === "string") {
         return typeof (value) === "string";
@@ -23,151 +325,550 @@ const matchesType = (type, value) => {
     if (type === "integer") {
         return typeof (value) === "number" && Number.isInteger(value);
     }
-    return true;
+    return false;
 };
-const checkSchema = (schema, value, at, depth, problems) => {
-    if (depth > 32) {
-        problems.push(`${at}: schema nesting exceeds 32`);
-        return;
+const decodePointer = (name) => name.replaceAll("~1", "/").replaceAll("~0", "~");
+/**
+ * Resolve the three reference forms this validator accepts. Anything else —
+ * external URLs, other pointers, missing definitions — is a schema problem.
+ */
+const resolveRef = (ref, root, at, problems) => {
+    if (ref === "#") {
+        return root;
     }
-    if (!isRecord(schema)) {
-        problems.push(`${at}: schema must be an object`);
-        return;
+    const prefixes = ["#/$defs/", "#/definitions/"];
+    for (let index = 0; index < prefixes.length; index += 1) {
+        const prefix = prefixes[index];
+        if (!ref.startsWith(prefix)) {
+            continue;
+        }
+        const encoded = ref.slice(prefix.length);
+        if (encoded.length === 0 || encoded.includes("/")) {
+            break;
+        }
+        const name = decodePointer(encoded);
+        const container = isPlainObject(root)
+            ? isPlainObject(root[prefix === "#/$defs/" ? "$defs" : "definitions"])
+                ? root[prefix === "#/$defs/" ? "$defs" : "definitions"]
+                : (void 0)
+            : (void 0);
+        if (container === (void 0) || !Object.hasOwn(container, name)) {
+            problems.push(`${at}: $ref "${ref}" cannot be resolved`);
+            return (void 0);
+        }
+        const target = container[name];
+        if (typeof (target) === "boolean" || isPlainObject(target)) {
+            return target;
+        }
+        problems.push(`${at}: $ref "${ref}" does not point at a schema`);
+        return (void 0);
     }
-    if ("const" in schema && canonical(schema.const) !== canonical(value)) {
-        problems.push(`${at} must equal the const value`);
+    problems.push(`${at}: $ref "${ref}" is not a local reference (only #, #/$defs/<name>, #/definitions/<name>)`);
+    return (void 0);
+};
+const schemaMatches = (schema, value, depth, root) => {
+    const problems = [];
+    checkSchema(schema, value, "$", depth, root, problems);
+    return problems.length === 0;
+};
+const checkObjectKeywords = (schema, value, at, depth, root, problems) => {
+    if (!isPlainObject(schema) || !isPlainObject(value)) {
+        return;
     }
-    if (Array.isArray(schema.enum) && !schema.enum.some((item) => canonical(item) === canonical(value))) {
-        problems.push(`${at} is not one of the allowed values`);
+    const keys = Object.keys(value);
+    const requiredNames = readStringArray(schema, "required", at, problems);
+    if (requiredNames !== (void 0)) {
+        for (let index = 0; index < requiredNames.length; index += 1) {
+            const name = requiredNames[index];
+            if (!Object.hasOwn(value, name)) {
+                problems.push(`${at}.${name} is required`);
+            }
+        }
     }
-    if (Array.isArray(schema.allOf)) {
-        schema.allOf.forEach((branch) => checkSchema(branch, value, at, depth + 1, problems));
+    const hasProperties = Object.hasOwn(schema, "properties");
+    const properties = readPlainObject(schema, "properties", at, problems);
+    const hasAdditional = Object.hasOwn(schema, "additionalProperties");
+    let additional = (void 0);
+    let additionalValid = false;
+    if (hasAdditional) {
+        const declared = schema.additionalProperties;
+        if (typeof (declared) === "boolean" || isPlainObject(declared)) {
+            additional = declared;
+            additionalValid = true;
+        }
+        else {
+            problems.push(`${at}: "additionalProperties" must be a boolean or a schema`);
+        }
     }
-    if (Array.isArray(schema.anyOf) && !schema.anyOf.some((branch) => schemaMatches(branch, value, depth + 1))) {
-        problems.push(`${at} matches none of anyOf`);
+    if (!hasProperties && additionalValid && additional === false) {
+        if (keys.length > 0) {
+            problems.push(`${at} does not allow properties`);
+        }
     }
-    if (Array.isArray(schema.oneOf)) {
-        const matched = schema.oneOf.filter((branch) => schemaMatches(branch, value, depth + 1)).length;
-        if (matched !== 1) {
-            problems.push(`${at} matches ${matched} of oneOf, expected exactly 1`);
+    else {
+        for (let index = 0; index < keys.length; index += 1) {
+            const key = keys[index];
+            const child = value[key];
+            if (properties !== (void 0) && Object.hasOwn(properties, key)) {
+                checkSchema(properties[key], child, `${at}.${key}`, depth + 1, root, problems);
+            }
+            else if (additionalValid && additional === false) {
+                problems.push(`${at}.${key} is not allowed`);
+            }
+            else if (additionalValid && isPlainObject(additional)) {
+                checkSchema(additional, child, `${at}.${key}`, depth + 1, root, problems);
+            }
         }
     }
-    const declared = schema.type;
-    const types = Array.isArray(declared)
-        ? declared.filter((item) => typeof (item) === "string")
-        : typeof (declared) === "string"
-            ? [declared]
-            : [];
-    if (types.length > 0 && !types.some((type) => matchesType(type, value))) {
-        problems.push(`${at} expected ${types.join("|")}`);
-        return;
+    const minProperties = readCount(schema, "minProperties", at, problems);
+    if (minProperties !== (void 0) && keys.length < minProperties) {
+        problems.push(`${at} needs at least ${minProperties} properties`);
     }
-    if (Array.isArray(value)) {
-        if (Array.isArray(schema.items)) {
-            schema.items.forEach((item, index) => {
-                if (index < value.length) {
-                    checkSchema(item, value[index], `${at}[${index}]`, depth + 1, problems);
-                }
-            });
+    const maxProperties = readCount(schema, "maxProperties", at, problems);
+    if (maxProperties !== (void 0) && keys.length > maxProperties) {
+        problems.push(`${at} allows at most ${maxProperties} properties`);
+    }
+    if (Object.hasOwn(schema, "dependentRequired")) {
+        const dependent = schema.dependentRequired;
+        if (!isPlainObject(dependent)) {
+            problems.push(`${at}: "dependentRequired" must be an object`);
         }
-        else if (schema.items !== (void 0)) {
-            value.forEach((item, index) => checkSchema(schema.items, item, `${at}[${index}]`, depth + 1, problems));
+        else {
+            const triggers = Object.keys(dependent);
+            for (let index = 0; index < triggers.length; index += 1) {
+                const trigger = triggers[index];
+                const dependency = dependent[trigger];
+                if (!Array.isArray(dependency) || !dependency.every((item) => typeof (item) === "string")) {
+                    problems.push(`${at}: "dependentRequired.${trigger}" must be an array of strings`);
+                    continue;
+                }
+                if (!Object.hasOwn(value, trigger)) {
+                    continue;
+                }
+                for (let dependencyIndex = 0; dependencyIndex < dependency.length; dependencyIndex += 1) {
+                    const name = dependency[dependencyIndex];
+                    if (!Object.hasOwn(value, name)) {
+                        problems.push(`${at}.${name} is required when ${at}.${trigger} is present`);
+                    }
+                }
+            }
         }
-        const minItems = schema.minItems;
-        const maxItems = schema.maxItems;
-        if (typeof (minItems) === "number" && value.length < minItems) {
-            problems.push(`${at} needs at least ${minItems} items`);
+    }
+    if (Object.hasOwn(schema, "propertyNames")) {
+        const declared = schema.propertyNames;
+        if (typeof (declared) !== "boolean" && !isPlainObject(declared)) {
+            problems.push(`${at}: "propertyNames" must be an object or a boolean schema`);
         }
-        if (typeof (maxItems) === "number" && value.length > maxItems) {
-            problems.push(`${at} allows at most ${maxItems} items`);
+        else {
+            for (let index = 0; index < keys.length; index += 1) {
+                checkSchema(declared, keys[index], `${at}.${keys[index]}`, depth + 1, root, problems);
+            }
         }
+    }
+};
+const checkArrayKeywords = (schema, value, at, depth, root, problems) => {
+    if (!isPlainObject(schema) || !Array.isArray(value)) {
         return;
     }
-    if (isRecord(value)) {
-        const required = schema.required;
-        if (Array.isArray(required)) {
-            for (let index = 0; index < required.length; index += 1) {
-                const name = required[index];
-                if (typeof (name) === "string" && !(name in value)) {
-                    problems.push(`${at}.${name} is required`);
+    const hasItems = Object.hasOwn(schema, "items");
+    let single = (void 0);
+    let singleValid = false;
+    let tuple = (void 0);
+    if (hasItems) {
+        const declared = schema.items;
+        if (Array.isArray(declared)) {
+            let valid = true;
+            for (let index = 0; index < declared.length; index += 1) {
+                if (!isSchemaNode(declared[index])) {
+                    problems.push(`${at}: "items[${index}]" must be a schema`);
+                    valid = false;
                 }
             }
+            if (valid) {
+                tuple = declared;
+            }
         }
-        const properties = schema.properties;
-        if (isRecord(properties)) {
-            const keys = Object.keys(value);
-            for (let index = 0; index < keys.length; index += 1) {
-                const key = keys[index];
-                const child = properties[key];
-                if (child !== (void 0)) {
-                    checkSchema(child, value[key], `${at}.${key}`, depth + 1, problems);
+        else if (typeof (declared) === "boolean" || isPlainObject(declared)) {
+            single = declared;
+            singleValid = true;
+        }
+        else {
+            problems.push(`${at}: "items" must be an object, a boolean or an array of schemas`);
+        }
+    }
+    if (tuple !== (void 0)) {
+        for (let index = 0; index < tuple.length; index += 1) {
+            if (index < value.length) {
+                checkSchema(tuple[index], value[index], `${at}[${index}]`, depth + 1, root, problems);
+            }
+        }
+        if (Object.hasOwn(schema, "additionalItems")) {
+            const extra = schema.additionalItems;
+            if (extra === false) {
+                if (value.length > tuple.length) {
+                    problems.push(`${at} allows at most ${tuple.length} items`);
                 }
-                else if (schema.additionalProperties === false) {
-                    problems.push(`${at}.${key} is not allowed`);
+            }
+            else if (typeof (extra) === "boolean" || isPlainObject(extra)) {
+                for (let index = tuple.length; index < value.length; index += 1) {
+                    checkSchema(extra, value[index], `${at}[${index}]`, depth + 1, root, problems);
                 }
             }
+            else {
+                problems.push(`${at}: "additionalItems" must be a boolean or a schema`);
+            }
         }
-        else if (schema.additionalProperties === false && Object.keys(value).length > 0) {
-            problems.push(`${at} does not allow properties`);
+    }
+    else {
+        if (singleValid) {
+            for (let index = 0; index < value.length; index += 1) {
+                checkSchema(single, value[index], `${at}[${index}]`, depth + 1, root, problems);
+            }
+        }
+        if (Object.hasOwn(schema, "additionalItems") && !Array.isArray(schema.items)) {
+            problems.push(`${at}: "additionalItems" requires "items" to be an array of schemas`);
+        }
+    }
+    const minItems = readCount(schema, "minItems", at, problems);
+    if (minItems !== (void 0) && value.length < minItems) {
+        problems.push(`${at} needs at least ${minItems} items`);
+    }
+    const maxItems = readCount(schema, "maxItems", at, problems);
+    if (maxItems !== (void 0) && value.length > maxItems) {
+        problems.push(`${at} allows at most ${maxItems} items`);
+    }
+    const uniqueItems = readBoolean(schema, "uniqueItems", at, problems);
+    if (uniqueItems === true) {
+        const seen = new Set();
+        for (let index = 0; index < value.length; index += 1) {
+            const key = canonical(value[index]);
+            if (seen.has(key)) {
+                problems.push(`${at}[${index}] duplicates an earlier item`);
+            }
+            else {
+                seen.add(key);
+            }
         }
+    }
+};
+const checkStringKeywords = (schema, value, at, problems, pattern, patternSource, format) => {
+    const length = Array.from(value).length;
+    const minLength = readCount(schema, "minLength", at, problems);
+    if (minLength !== (void 0) && length < minLength) {
+        problems.push(`${at} is shorter than ${minLength}`);
+    }
+    const maxLength = readCount(schema, "maxLength", at, problems);
+    if (maxLength !== (void 0) && length > maxLength) {
+        problems.push(`${at} is longer than ${maxLength}`);
+    }
+    if (pattern !== (void 0) && !pattern.test(value)) {
+        problems.push(`${at} does not match ${patternSource}`);
+    }
+    if (format !== (void 0) && !formatMatches(format, value)) {
+        problems.push(`${at} is not a valid ${format}`);
+    }
+};
+const checkNumberKeywords = (schema, value, at, _depth, _root, problems) => {
+    if (!isPlainObject(schema) || typeof (value) !== "number") {
         return;
     }
-    if (typeof (value) === "string") {
-        const minLength = schema.minLength;
-        const maxLength = schema.maxLength;
-        const pattern = schema.pattern;
-        if (typeof (minLength) === "number" && value.length < minLength) {
-            problems.push(`${at} is shorter than ${minLength}`);
+    const minimum = readFiniteNumber(schema, "minimum", at, problems);
+    if (minimum !== (void 0) && value < minimum) {
+        problems.push(`${at} is below ${minimum}`);
+    }
+    const maximum = readFiniteNumber(schema, "maximum", at, problems);
+    if (maximum !== (void 0) && value > maximum) {
+        problems.push(`${at} is above ${maximum}`);
+    }
+    let exclusiveMinimum = (void 0);
+    if (Object.hasOwn(schema, "exclusiveMinimum")) {
+        const declared = schema.exclusiveMinimum;
+        if (typeof (declared) === "number" && Number.isFinite(declared)) {
+            exclusiveMinimum = declared;
+        }
+        else if (declared === true) {
+            if (minimum === (void 0)) {
+                problems.push(`${at}: "exclusiveMinimum" requires a numeric "minimum"`);
+            }
+            else {
+                exclusiveMinimum = minimum;
+            }
+        }
+        else if (declared !== false) {
+            problems.push(`${at}: "exclusiveMinimum" must be a number or a boolean`);
         }
-        if (typeof (maxLength) === "number" && value.length > maxLength) {
-            problems.push(`${at} is longer than ${maxLength}`);
+    }
+    if (exclusiveMinimum !== (void 0) && value <= exclusiveMinimum) {
+        problems.push(`${at} must be greater than ${exclusiveMinimum}`);
+    }
+    let exclusiveMaximum = (void 0);
+    if (Object.hasOwn(schema, "exclusiveMaximum")) {
+        const declared = schema.exclusiveMaximum;
+        if (typeof (declared) === "number" && Number.isFinite(declared)) {
+            exclusiveMaximum = declared;
+        }
+        else if (declared === true) {
+            if (maximum === (void 0)) {
+                problems.push(`${at}: "exclusiveMaximum" requires a numeric "maximum"`);
+            }
+            else {
+                exclusiveMaximum = maximum;
+            }
+        }
+        else if (declared !== false) {
+            problems.push(`${at}: "exclusiveMaximum" must be a number or a boolean`);
+        }
+    }
+    if (exclusiveMaximum !== (void 0) && value >= exclusiveMaximum) {
+        problems.push(`${at} must be less than ${exclusiveMaximum}`);
+    }
+    if (Object.hasOwn(schema, "multipleOf")) {
+        const declared = schema.multipleOf;
+        if (typeof (declared) !== "number" || !Number.isFinite(declared) || declared <= 0) {
+            problems.push(`${at}: "multipleOf" must be a positive finite number`);
+        }
+        else {
+            const quotient = value / declared;
+            if (Math.abs(quotient - Math.round(quotient)) > 1e-9 * Math.max(1, Math.abs(quotient))) {
+                problems.push(`${at} is not a multiple of ${declared}`);
+            }
+        }
+    }
+};
+const checkSchema = (schema, value, at, depth, root, problems) => {
+    if (depth > MaxSchemaDepth) {
+        problems.push(`${at}: schema nesting exceeds ${MaxSchemaDepth}`);
+        return;
+    }
+    if (typeof (schema) === "boolean") {
+        if (!schema) {
+            problems.push(`${at} does not accept any value`);
+        }
+        return;
+    }
+    if (!isPlainObject(schema)) {
+        problems.push(`${at}: schema must be an object or a boolean`);
+        return;
+    }
+    const keywords = Object.keys(schema);
+    for (let index = 0; index < keywords.length; index += 1) {
+        const keyword = keywords[index];
+        if (!SupportedKeywords.includes(keyword) && !AnnotationKeywords.includes(keyword)) {
+            problems.push(`${at}: unsupported keyword "${keyword}"`);
+        }
+    }
+    /*
+     * `pattern` and `format` are validated on the schema itself, not only when
+     * the value happens to be a string, so a broken keyword cannot hide behind
+     * a value of another type.
+     */
+    let patternRegExp = (void 0);
+    let patternSource = (void 0);
+    if (Object.hasOwn(schema, "pattern")) {
+        const declared = schema.pattern;
+        if (typeof (declared) !== "string") {
+            problems.push(`${at}: "pattern" must be a string`);
         }
-        if (typeof (pattern) === "string") {
+        else {
+            patternSource = declared;
             try {
-                if (!new RegExp(pattern).test(value)) {
-                    problems.push(`${at} does not match ${pattern}`);
-                }
+                patternRegExp = new RegExp(declared);
             }
             catch {
-                problems.push(`${at} has an invalid pattern`);
+                problems.push(`${at}: invalid pattern ${JSON.stringify(declared)}`);
             }
         }
     }
-    if (typeof (value) === "number") {
-        const minimum = schema.minimum;
-        const maximum = schema.maximum;
-        if (typeof (minimum) === "number" && value < minimum) {
-            problems.push(`${at} is below ${minimum}`);
+    let formatName = (void 0);
+    if (Object.hasOwn(schema, "format")) {
+        const declared = schema.format;
+        if (typeof (declared) !== "string") {
+            problems.push(`${at}: "format" must be a string`);
         }
-        if (typeof (maximum) === "number" && value > maximum) {
-            problems.push(`${at} is above ${maximum}`);
+        else if (!SupportedFormats.includes(declared)) {
+            problems.push(`${at}: unsupported format "${declared}"`);
+        }
+        else {
+            formatName = declared;
         }
     }
-};
-const schemaMatches = (schema, value, depth) => {
-    const problems = [];
-    checkSchema(schema, value, "$", depth, problems);
-    return problems.length === 0;
+    if (Object.hasOwn(schema, "$ref")) {
+        const ref = readString(schema, "$ref", at, problems);
+        if (ref !== (void 0)) {
+            const resolved = resolveRef(ref, root, at, problems);
+            if (resolved !== (void 0)) {
+                checkSchema(resolved, value, at, depth + 1, root, problems);
+            }
+        }
+    }
+    if (Object.hasOwn(schema, "const")) {
+        const constValue = schema.const;
+        const constProblem = jsonValueProblem(constValue, `${at}.const`);
+        if (constProblem !== (void 0)) {
+            problems.push(`${at}: "const" is not JSON (${constProblem})`);
+        }
+        else if (!sameJson(constValue, value)) {
+            problems.push(`${at} must equal the const value`);
+        }
+    }
+    const allowedValues = readEnum(schema, at, problems);
+    if (allowedValues !== (void 0) && !allowedValues.some((item) => sameJson(item, value))) {
+        problems.push(`${at} is not one of the allowed values`);
+    }
+    const allOf = readSchemaArray(schema, "allOf", at, problems);
+    if (allOf !== (void 0)) {
+        for (let index = 0; index < allOf.length; index += 1) {
+            checkSchema(allOf[index], value, at, depth + 1, root, problems);
+        }
+    }
+    const anyOf = readSchemaArray(schema, "anyOf", at, problems);
+    if (anyOf !== (void 0)) {
+        let matched = false;
+        for (let index = 0; index < anyOf.length; index += 1) {
+            if (schemaMatches(anyOf[index], value, depth + 1, root)) {
+                matched = true;
+            }
+        }
+        if (!matched) {
+            problems.push(`${at} matches none of anyOf`);
+        }
+    }
+    const oneOf = readSchemaArray(schema, "oneOf", at, problems);
+    if (oneOf !== (void 0)) {
+        let matched = 0;
+        for (let index = 0; index < oneOf.length; index += 1) {
+            if (schemaMatches(oneOf[index], value, depth + 1, root)) {
+                matched += 1;
+            }
+        }
+        if (matched !== 1) {
+            problems.push(`${at} matches ${matched} of oneOf, expected exactly 1`);
+        }
+    }
+    if (Object.hasOwn(schema, "type")) {
+        const types = readTypes(schema, at, problems);
+        if (types !== (void 0) && !types.some((type) => matchesType(type, value))) {
+            problems.push(`${at} expected ${types.join("|")}`);
+            return;
+        }
+    }
+    if (Array.isArray(value)) {
+        checkArrayKeywords(schema, value, at, depth, root, problems);
+        return;
+    }
+    if (isPlainObject(value)) {
+        checkObjectKeywords(schema, value, at, depth, root, problems);
+        return;
+    }
+    if (typeof (value) === "string") {
+        checkStringKeywords(schema, value, at, problems, patternRegExp, patternSource, formatName);
+        return;
+    }
+    if (typeof (value) === "number") {
+        checkNumberKeywords(schema, value, at, depth, root, problems);
+    }
 };
 /**
  * Parse a tool call's arguments against its declared schema.
  *
+ * The returned `args` is a deep-frozen clone of `raw`: mutating the caller's
+ * object afterwards changes neither `args` nor `digest`.
+ *
  * @throws BoundaryRejection `invalid_tool_args` with every problem found.
  */
-export const parseToolCall = (tool, raw) => {
+const parseToolCallInner = (tool, raw) => {
     const problems = [];
-    if (typeof (tool.name) !== "string" || tool.name.length === 0) {
-        problems.push("tool.name is empty");
+    let name = "";
+    let schemaValue = (void 0);
+    let schemaUsable = false;
+    let rawObject = (void 0);
+    const candidate = tool;
+    if (!isPlainObject(candidate)) {
+        problems.push("tool must be an object with a name and an inputSchema");
     }
-    if (!isRecord(raw)) {
+    else {
+        try {
+            const declaredName = candidate.name;
+            if (typeof (declaredName) !== "string" || declaredName.length === 0) {
+                problems.push("tool.name must be a non-empty string");
+            }
+            else {
+                name = declaredName;
+            }
+            if (!Object.hasOwn(candidate, "inputSchema")) {
+                problems.push("tool.inputSchema is required (object or boolean)");
+            }
+            else {
+                const declaredSchema = candidate.inputSchema;
+                if (typeof (declaredSchema) === "boolean" || isPlainObject(declaredSchema)) {
+                    schemaValue = declaredSchema;
+                    schemaUsable = true;
+                }
+                else {
+                    problems.push("tool.inputSchema must be an object or a boolean");
+                }
+            }
+        }
+        catch (error) {
+            problems.push(`tool cannot be inspected (${error instanceof Error ? error.name : typeof (error)})`);
+        }
+    }
+    if (!isPlainObject(raw)) {
         problems.push("arguments must be an object");
     }
     else {
-        checkSchema(tool.inputSchema, raw, "$", 0, problems);
+        let jsonProblem = (void 0);
+        try {
+            jsonProblem = jsonValueProblem(raw);
+        }
+        catch (error) {
+            jsonProblem = `arguments cannot be inspected (${error instanceof Error ? error.name : typeof (error)})`;
+        }
+        if (jsonProblem !== (void 0)) {
+            problems.push(jsonProblem);
+        }
+        else {
+            rawObject = raw;
+        }
+    }
+    if (schemaUsable && rawObject !== (void 0)) {
+        try {
+            checkSchema(schemaValue, rawObject, "$", 0, schemaValue, problems);
+        }
+        catch (error) {
+            problems.push(`arguments cannot be validated (${error instanceof Error ? error.name : typeof (error)})`);
+        }
     }
     if (problems.length > 0) {
         throw new BoundaryRejection("invalid_tool_args", problems);
     }
-    const args = raw;
-    return { tool: tool.name, args, digest: digestOf(args) };
+    const accepted = rawObject;
+    if (accepted === (void 0)) {
+        throw new BoundaryRejection("invalid_tool_args", ["arguments must be an object"]);
+    }
+    try {
+        const args = deepFreezeJson(cloneJson(accepted));
+        return { tool: name, args, digest: digestOf(args) };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new BoundaryRejection("invalid_tool_args", [`arguments are not strict JSON: ${reason}`]);
+    }
+};
+/**
+ * Public entry point. The inner checks catch the common inspection failures;
+ * this outer guard covers a revoked `Proxy` whose very prototype lookup throws
+ * before the inner `try` blocks run.
+ */
+export const parseToolCall = (tool, raw) => {
+    try {
+        return parseToolCallInner(tool, raw);
+    }
+    catch (error) {
+        if (error instanceof BoundaryRejection) {
+            throw error;
+        }
+        const reason = error instanceof Error ? error.message : typeof (error);
+        throw new BoundaryRejection("invalid_tool_args", [`arguments could not be inspected: ${reason}`]);
+    }
 };