@agent-native/core 0.132.0 → 0.132.2

package/dist/agent/production-agent.js

@@ -2531,6 +2531,9 @@ const rawToolInputAjv = new Ajv({
     coerceTypes: true,
     useDefaults: false,
     removeAdditional: false,
+    // `parentSchema`/`data` on each error are what let us drop the branches of a
+    // `oneOf` the caller never meant to match.
+    verbose: true,
 });
 const rawToolInputValidatorCache = new WeakMap();
 const optionalPlaceholderAjv = new Ajv({
@@ -2559,51 +2562,148 @@ function isStructurallyEmptyToolValue(value) {
         value !== null &&
         Object.keys(value).length === 0);
 }
+function compileToolValueValidator(schema) {
+    const cached = optionalPlaceholderValidatorCache.get(schema);
+    if (cached)
+        return cached;
+    try {
+        const validator = optionalPlaceholderAjv.compile(schema);
+        optionalPlaceholderValidatorCache.set(schema, validator);
+        return validator;
+    }
+    catch {
+        return null;
+    }
+}
 function schemaAcceptsToolValue(schema, value) {
-    let validator = optionalPlaceholderValidatorCache.get(schema);
-    if (!validator) {
-        try {
-            validator = optionalPlaceholderAjv.compile(schema);
-            optionalPlaceholderValidatorCache.set(schema, validator);
-        }
-        catch {
-            return false;
-        }
+    const validator = compileToolValueValidator(schema);
+    return validator ? Boolean(validator(value)) : false;
+}
+/**
+ * True only when the sub-schema compiled AND rejected the value. A sub-schema
+ * that cannot be compiled standalone — a `$ref` into the root `$defs`, say — is
+ * unknown, not invalid; counting it as invalid would let one unreadable
+ * sub-schema delete the caller's intentional empty values everywhere else in
+ * the same object.
+ */
+function schemaRejectsToolValue(schema, value) {
+    const validator = compileToolValueValidator(schema);
+    return validator ? !validator(value) : false;
+}
+/** The `const`/single-value-`enum` a discriminated-union branch pins a key to. */
+function schemaDiscriminatorValue(schema) {
+    if (!schema)
+        return undefined;
+    if (schema.const !== undefined)
+        return schema.const;
+    if (Array.isArray(schema.enum) && schema.enum.length === 1) {
+        return schema.enum[0];
     }
-    return Boolean(validator(value));
+    return undefined;
+}
+/**
+ * Index of the `oneOf`/`anyOf` branch whose discriminator constants all match
+ * `value`, or -1 when the union is not discriminated or nothing matches.
+ */
+function discriminatedBranchIndex(branches, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return -1;
+    const record = value;
+    return branches.findIndex((branch) => {
+        const properties = branch.properties;
+        if (!properties)
+            return false;
+        const discriminators = Object.entries(properties).filter(([, spec]) => schemaDiscriminatorValue(spec) !== undefined);
+        if (discriminators.length === 0)
+            return false;
+        return discriminators.every(([key, spec]) => record[key] === schemaDiscriminatorValue(spec));
+    });
+}
+/**
+ * The object schema that actually governs `value` — the union branch its
+ * discriminator selects, or the schema itself. Undefined when a union cannot be
+ * resolved, since guessing a branch would strip the wrong keys.
+ */
+function resolveObjectSchemaBranch(schema, value) {
+    const branches = schema.oneOf ?? schema.anyOf;
+    if (!branches?.length)
+        return schema;
+    const index = discriminatedBranchIndex(branches, value);
+    return index >= 0 ? branches[index] : undefined;
 }
 /**
  * Some model gateways fill every optional tool field with an empty sentinel
  * instead of omitting it. One schema-invalid empty value proves that pattern;
  * only then strip the other optional empty/default sentinels from the call.
  * Calls whose empty values are all schema-valid keep their intentional clears.
+ *
+ * The proof is evaluated per object, and the walk descends through array items
+ * and discriminated-union branches: gateways pre-fill the leaf object they are
+ * building (`operations[0].fields`), which a top-level-only sweep never reaches.
  */
-function normalizeOptionalToolPlaceholders(schema, input) {
-    if (!schema?.properties || !input || typeof input !== "object") {
-        return { input, changed: false };
+function stripOptionalToolPlaceholders(schema, value) {
+    if (!schema)
+        return { value, changed: false };
+    if (Array.isArray(value)) {
+        const itemSchema = schema.items;
+        if (!itemSchema)
+            return { value, changed: false };
+        let changed = false;
+        const items = value.map((item) => {
+            const result = stripOptionalToolPlaceholders(itemSchema, item);
+            if (result.changed)
+                changed = true;
+            return result.value;
+        });
+        return changed
+            ? { value: items, changed: true }
+            : { value, changed: false };
     }
-    if (Array.isArray(input))
-        return { input, changed: false };
-    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    if (!value || typeof value !== "object")
+        return { value, changed: false };
+    const objectSchema = resolveObjectSchemaBranch(schema, value);
+    const properties = objectSchema?.properties;
+    if (!properties)
+        return { value, changed: false };
+    const required = new Set(Array.isArray(objectSchema.required) ? objectSchema.required : []);
+    const record = value;
     const placeholders = [];
     let hasSchemaInvalidPlaceholder = false;
-    for (const [key, value] of Object.entries(input)) {
-        if (required.has(key) || !isStructurallyEmptyToolValue(value))
-            continue;
-        const propertySchema = schema.properties[key];
+    let normalized = null;
+    for (const [key, entry] of Object.entries(record)) {
+        const propertySchema = properties[key];
         if (!propertySchema || typeof propertySchema !== "object")
             continue;
-        placeholders.push(key);
-        if (!schemaAcceptsToolValue(propertySchema, value)) {
-            hasSchemaInvalidPlaceholder = true;
+        if (!required.has(key) && isStructurallyEmptyToolValue(entry)) {
+            placeholders.push(key);
+            if (schemaRejectsToolValue(propertySchema, entry)) {
+                hasSchemaInvalidPlaceholder = true;
+            }
+            continue;
+        }
+        const nested = stripOptionalToolPlaceholders(propertySchema, entry);
+        if (nested.changed) {
+            normalized ??= { ...record };
+            normalized[key] = nested.value;
         }
     }
-    if (!hasSchemaInvalidPlaceholder)
+    if (hasSchemaInvalidPlaceholder) {
+        normalized ??= { ...record };
+        for (const key of placeholders)
+            delete normalized[key];
+    }
+    return normalized
+        ? { value: normalized, changed: true }
+        : { value, changed: false };
+}
+function normalizeOptionalToolPlaceholders(schema, input) {
+    if (!schema?.properties || !input || typeof input !== "object") {
+        return { input, changed: false };
+    }
+    if (Array.isArray(input))
         return { input, changed: false };
-    const normalized = { ...input };
-    for (const key of placeholders)
-        delete normalized[key];
-    return { input: normalized, changed: true };
+    const result = stripOptionalToolPlaceholders(schema, input);
+    return { input: result.value, changed: result.changed };
 }
 /**
  * Models routinely JSON-encode a field's value into a string when the tool
@@ -2672,6 +2772,54 @@ function shouldValidateRawToolParameters(entry) {
     const maybeSchema = entry.schema;
     return !maybeSchema?.["~standard"] && Boolean(entry.tool.parameters);
 }
+/**
+ * With `allErrors`, a failing union reports every branch, so a five-branch
+ * union answers "your `patch-deck-fields` op has a bad enum" with eight
+ * complaints about `slideId`/`orderedIds` from the four branches the caller
+ * never meant. The model reads the loudest, wrong advice and re-sends the same
+ * arguments until the identical-error breaker ends the turn. When the
+ * discriminator names a branch, report only that branch's errors.
+ *
+ * Both union keywords are load-bearing for the same Zod schema: Zod v4's own
+ * `toJSONSchema` emits `oneOf` for a discriminated union, while the manual
+ * fallback converter in `action.ts` emits `anyOf`.
+ *
+ * Scoped by `instancePath` as well as `schemaPath`: every element of an array
+ * shares one `items` schema, so `operations[0]` and `operations[1]` produce
+ * branch errors under the same `schemaPath` and only the instance path says
+ * which element they belong to.
+ */
+function isWithinInstancePath(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}/`);
+}
+function narrowUnionBranchErrors(errors) {
+    if (!errors?.length)
+        return errors;
+    let kept = errors;
+    for (const error of errors) {
+        const keyword = error.keyword;
+        if (keyword !== "oneOf" && keyword !== "anyOf")
+            continue;
+        const branches = error.parentSchema?.[keyword];
+        if (!branches?.length)
+            continue;
+        const index = discriminatedBranchIndex(branches, error.data);
+        if (index < 0)
+            continue;
+        const branchPrefix = `${error.schemaPath}/`;
+        kept = kept.filter((candidate) => {
+            if (candidate === error)
+                return false;
+            if (!isWithinInstancePath(candidate.instancePath, error.instancePath)) {
+                return true;
+            }
+            if (!candidate.schemaPath.startsWith(branchPrefix))
+                return true;
+            return candidate.schemaPath.startsWith(`${branchPrefix}${index}/`);
+        });
+    }
+    return kept.length ? kept : errors;
+}
 function validateRawToolInput(entry, input) {
     if (!shouldValidateRawToolParameters(entry))
         return null;
@@ -2687,7 +2835,7 @@ function validateRawToolInput(entry, input) {
     }
     if (validator(input === undefined ? {} : input))
         return null;
-    return rawToolInputAjv.errorsText(validator.errors, {
+    return rawToolInputAjv.errorsText(narrowUnionBranchErrors(validator.errors), {
         separator: "; ",
         dataVar: "input",
     });