@agent-native/core 0.122.0 → 0.122.2

package/dist/agent/production-agent.js

@@ -2393,6 +2393,61 @@ function normalizeOptionalToolPlaceholders(schema, input) {
         delete normalized[key];
     return { input: normalized, changed: true };
 }
+/**
+ * Models routinely JSON-encode a field's value into a string when the tool
+ * schema wants an object/array — e.g. `config: "{\"name\":...}"` instead of
+ * `config: {name:...}`, or `operations: "[...]"` instead of `operations: [...]`.
+ * Seen across every app profiled in the 2026-07-25 reliability sweep
+ * (brain's `update-source` config, analytics' `mutate-dashboard`/
+ * `update-dashboard` operations/ops/config) and the model does NOT
+ * self-correct across repeated identical retries — it burns the full
+ * `MAX_IDENTICAL_TOOL_ERRORS` retry budget on the same wrong shape every
+ * time. Evidence-gated exactly like `normalizeOptionalToolPlaceholders`:
+ * only coerce a field whose CURRENT value fails schema validation (so a
+ * legitimate string value is never touched — a field schema-valid as a
+ * string is never also schema-valid as object/array) and whose parsed form
+ * passes. Never touches values that are already the right shape.
+ */
+function coerceStringifiedJsonToolValues(schema, input) {
+    if (!schema?.properties || !input || typeof input !== "object") {
+        return { input, changed: false };
+    }
+    if (Array.isArray(input))
+        return { input, changed: false };
+    let normalized = null;
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value !== "string" || value.trim().length === 0)
+            continue;
+        const propertySchema = schema.properties[key];
+        if (!propertySchema || typeof propertySchema !== "object")
+            continue;
+        const expectedType = propertySchema.type;
+        const expectsObjectOrArray = expectedType === "object" ||
+            expectedType === "array" ||
+            (Array.isArray(expectedType) &&
+                (expectedType.includes("object") || expectedType.includes("array")));
+        if (!expectsObjectOrArray)
+            continue;
+        if (schemaAcceptsToolValue(propertySchema, value))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed !== "object" || parsed === null)
+            continue;
+        if (!schemaAcceptsToolValue(propertySchema, parsed))
+            continue;
+        normalized ??= { ...input };
+        normalized[key] = parsed;
+    }
+    return normalized
+        ? { input: normalized, changed: true }
+        : { input, changed: false };
+}
 function getRawToolInputValidator(schema) {
     const cached = rawToolInputValidatorCache.get(schema);
     if (cached)
@@ -3169,6 +3224,13 @@ export async function runAgentLoop(opts) {
             if (placeholderNormalization.changed) {
                 toolCall = { ...toolCall, input: placeholderNormalization.input };
             }
+            const jsonStringCoercion = actionEntry
+                ? coerceStringifiedJsonToolValues(actionEntry.tool.parameters, toolCall.input)
+                : { input: toolCall.input, changed: false };
+            if (jsonStringCoercion.changed) {
+                toolCall = { ...toolCall, input: jsonStringCoercion.input };
+            }
+            const toolInputNormalized = placeholderNormalization.changed || jsonStringCoercion.changed;
             const wireToolInput = JSON.stringify(toolCall.input ?? {});
             const normalizedToolInput = normalizeToolCallInputForHistory(toolCall.input);
             const sourceSweepGuard = shouldGuardRepeatedSourceSweep({
@@ -3556,7 +3618,7 @@ export async function runAgentLoop(opts) {
                 input: toolCall.input,
             });
             const toolCallSchemaError = toolCallErrors.get(toolCall.id);
-            if (toolCallSchemaError && !placeholderNormalization.changed) {
+            if (toolCallSchemaError && !toolInputNormalized) {
                 const result = finalizeToolErrorResult(toolInputSchemaErrorResult(toolCall.name, toolCallSchemaError.input, toolCallSchemaError.error));
                 send({
                     type: "tool_done",