@agent-native/core 0.114.16 → 0.115.1

package/dist/agent/production-agent.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { defineEventHandler, getHeader, setResponseHeader, setResponseStatus, getMethod, } from "h3";
-import { isAgentActionStopError } from "../action.js";
+import { isAgentActionStopError, } from "../action.js";
 import { readAppState } from "../application-state/script-helpers.js";
 import { isReadOnlyShellCommand } from "../coding-tools/index.js";
 import { extensionIdFromPathname } from "../extensions/path.js";
@@ -2177,6 +2177,78 @@ const rawToolInputAjv = new Ajv({
     removeAdditional: false,
 });
 const rawToolInputValidatorCache = new WeakMap();
+const optionalPlaceholderAjv = new Ajv({
+    strict: false,
+    allErrors: false,
+    coerceTypes: false,
+    useDefaults: false,
+    removeAdditional: false,
+});
+const optionalPlaceholderValidatorCache = new WeakMap();
+function isStructurallyEmptyToolValue(value) {
+    if (value === false)
+        return true;
+    if (value === null)
+        return true;
+    if (typeof value === "string")
+        return value.trim().length === 0;
+    if (Array.isArray(value)) {
+        return (value.length === 0 ||
+            value.every((item) => item !== null &&
+                typeof item === "object" &&
+                !Array.isArray(item) &&
+                Object.keys(item).length === 0));
+    }
+    return (typeof value === "object" &&
+        value !== null &&
+        Object.keys(value).length === 0);
+}
+function schemaAcceptsToolValue(schema, value) {
+    let validator = optionalPlaceholderValidatorCache.get(schema);
+    if (!validator) {
+        try {
+            validator = optionalPlaceholderAjv.compile(schema);
+            optionalPlaceholderValidatorCache.set(schema, validator);
+        }
+        catch {
+            return false;
+        }
+    }
+    return Boolean(validator(value));
+}
+/**
+ * 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.
+ */
+function normalizeOptionalToolPlaceholders(schema, input) {
+    if (!schema?.properties || !input || typeof input !== "object") {
+        return { input, changed: false };
+    }
+    if (Array.isArray(input))
+        return { input, changed: false };
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    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];
+        if (!propertySchema || typeof propertySchema !== "object")
+            continue;
+        placeholders.push(key);
+        if (!schemaAcceptsToolValue(propertySchema, value)) {
+            hasSchemaInvalidPlaceholder = true;
+        }
+    }
+    if (!hasSchemaInvalidPlaceholder)
+        return { input, changed: false };
+    const normalized = { ...input };
+    for (const key of placeholders)
+        delete normalized[key];
+    return { input: normalized, changed: true };
+}
 function getRawToolInputValidator(schema) {
     const cached = rawToolInputValidatorCache.get(schema);
     if (cached)
@@ -2935,9 +3007,15 @@ export async function runAgentLoop(opts) {
         // call run. The model cannot populate this — it comes from the request.
         const approvedToolCallKeys = new Set(opts.approvedToolCalls ?? []);
         const runToolCall = async (toolCall) => {
+            const actionEntry = actions[toolCall.name];
+            const placeholderNormalization = actionEntry
+                ? normalizeOptionalToolPlaceholders(actionEntry.tool.parameters, toolCall.input)
+                : { input: toolCall.input, changed: false };
+            if (placeholderNormalization.changed) {
+                toolCall = { ...toolCall, input: placeholderNormalization.input };
+            }
             const wireToolInput = JSON.stringify(toolCall.input ?? {});
             const normalizedToolInput = normalizeToolCallInputForHistory(toolCall.input);
-            const actionEntry = actions[toolCall.name];
             const sourceSweepGuard = shouldGuardRepeatedSourceSweep({
                 toolName: toolCall.name,
                 entry: actionEntry,
@@ -3079,6 +3157,7 @@ export async function runAgentLoop(opts) {
                                 userEmail: getRequestUserEmail(),
                                 orgId: getRequestOrgId() ?? null,
                                 caller: opts.actionCaller ?? "tool",
+                                automation: opts.automation,
                                 networkProtocol: opts.networkProtocol,
                                 networkId: opts.networkId,
                                 networkPeer: opts.networkPeer,
@@ -3322,7 +3401,7 @@ export async function runAgentLoop(opts) {
                 input: toolCall.input,
             });
             const toolCallSchemaError = toolCallErrors.get(toolCall.id);
-            if (toolCallSchemaError) {
+            if (toolCallSchemaError && !placeholderNormalization.changed) {
                 const result = finalizeToolErrorResult(toolInputSchemaErrorResult(toolCall.name, toolCallSchemaError.input, toolCallSchemaError.error));
                 send({
                     type: "tool_done",
@@ -3462,6 +3541,7 @@ export async function runAgentLoop(opts) {
                     userEmail: actionUserEmail ?? undefined,
                     orgId: actionOrgId,
                     caller: opts.actionCaller ?? "tool",
+                    automation: opts.automation,
                     networkProtocol: opts.networkProtocol,
                     networkId: opts.networkId,
                     networkPeer: opts.networkPeer,