@lazyingart/agintiflow 0.20.285 → 0.20.286

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.285",
+  "version": "0.20.286",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/scripts/smoke-coding-tools.js

@@ -2482,6 +2482,93 @@ try {
       invalidFocusedRewrite.errors.some((error) => error.code === "ARGUMENT_PATTERN_MISMATCH"),
     "focused rewrite smoke input did not exercise the semantic pattern failure"
   );
+  const commandDescriptor = {
+    type: "function",
+    function: {
+      name: "run_command",
+      description: "Run one command.",
+      parameters: {
+        type: "object",
+        properties: { command: { type: "string", minLength: 1 } },
+        required: ["command"],
+        additionalProperties: false,
+      },
+    },
+  };
+  const annotatedCommandBatch = [
+    {
+      id: "annotated-command-one",
+      type: "function",
+      function: {
+        name: "run_command",
+        arguments: JSON.stringify({
+          command: "printf one",
+          description: "Inspect the first item",
+        }),
+      },
+    },
+    {
+      id: "annotated-command-two",
+      type: "function",
+      function: {
+        name: "run_command",
+        arguments: JSON.stringify({
+          command: "printf two",
+          description: "Inspect the second item",
+        }),
+      },
+    },
+  ];
+  const recoveredAnnotatedCommands = resolveDispatchableToolCallBatch(
+    annotatedCommandBatch,
+    createToolContract([commandDescriptor])
+  );
+  assert(recoveredAnnotatedCommands.ok, "benign command annotations were not normalized");
+  assert(
+    recoveredAnnotatedCommands.recoveredToolCallAnnotations,
+    "benign command annotation recovery was not recorded"
+  );
+  assert(
+    recoveredAnnotatedCommands.recoveredSequentially,
+    "annotated command batch did not retain bounded sequential dispatch"
+  );
+  assert(
+    recoveredAnnotatedCommands.acceptedToolCalls.length === 1 &&
+      recoveredAnnotatedCommands.deferredToolCalls.length === 1,
+    "annotated command batch did not dispatch one call and defer the suffix"
+  );
+  for (const call of [
+    ...recoveredAnnotatedCommands.acceptedToolCalls,
+    ...recoveredAnnotatedCommands.deferredToolCalls,
+  ]) {
+    assert(
+      !Object.hasOwn(JSON.parse(call.function.arguments), "description"),
+      "non-executable command description reached dispatch"
+    );
+  }
+  const unknownAnnotatedCommand = resolveDispatchableToolCallBatch(
+    [
+      {
+        id: "unknown-command-annotation",
+        type: "function",
+        function: {
+          name: "run_command",
+          arguments: JSON.stringify({
+            command: "printf blocked",
+            rationale: "This key is not an approved annotation",
+          }),
+        },
+      },
+    ],
+    createToolContract([commandDescriptor])
+  );
+  assert(
+    !unknownAnnotatedCommand.ok &&
+      unknownAnnotatedCommand.errors.some(
+        (error) => error.code === "ARGUMENT_ADDITIONAL_PROPERTY"
+      ),
+    "an unknown command annotation bypassed the exact tool schema"
+  );
   const focusedWriterCalls = [];
   const focusedRewriteState = {
     meta: {

package/src/tool-contract.js

@@ -30,6 +30,7 @@ const MAX_VALIDATION_ERRORS = 8;
 const MAX_VALIDATION_NODES = 50_000;
 const MAX_SAFE_SEQUENTIAL_READ_CALLS = 4;
 const MAX_REPORTED_SEQUENTIAL_CALLS = 12;
+const BENIGN_TOOL_CALL_ANNOTATION_KEYS = new Set(["description"]);
 
 function cloneValue(value) {
   return structuredClone(value);
@@ -457,6 +458,69 @@ function recoverBoundedCommitSubject(toolCalls, contract, validation) {
   };
 }
 
+function normalizeBenignToolCallAnnotations(toolCalls, contract) {
+  const calls = Array.isArray(toolCalls) ? toolCalls : [];
+  if (!calls.length || contract?.[contractMarker] !== true) return null;
+
+  const normalizedCalls = [];
+  const corrections = [];
+  for (let index = 0; index < calls.length; index += 1) {
+    const call = calls[index];
+    const toolName = String(call?.function?.name || "");
+    const descriptor = contract.tools.find(
+      (candidate) =>
+        candidate?.type === "function" && candidate.function?.name === toolName
+    );
+    if (!descriptor || typeof call?.function?.arguments !== "string") return null;
+
+    let args;
+    try {
+      args = JSON.parse(call.function.arguments);
+    } catch {
+      return null;
+    }
+    if (!isPlainObject(args)) return null;
+
+    const parameters = descriptor.function?.parameters;
+    const properties = isPlainObject(parameters?.properties)
+      ? parameters.properties
+      : {};
+    const correctedArgs = { ...args };
+    const removed = [];
+    for (const key of BENIGN_TOOL_CALL_ANNOTATION_KEYS) {
+      if (
+        parameters?.additionalProperties === false &&
+        !Object.hasOwn(properties, key) &&
+        Object.hasOwn(correctedArgs, key) &&
+        typeof correctedArgs[key] === "string" &&
+        correctedArgs[key].length <= 1_000
+      ) {
+        delete correctedArgs[key];
+        removed.push(key);
+        corrections.push({
+          callIndex: index,
+          property: key,
+          source: "non-executable-tool-annotation",
+        });
+      }
+    }
+
+    normalizedCalls.push(
+      removed.length
+        ? {
+            ...call,
+            function: {
+              ...call.function,
+              arguments: JSON.stringify(correctedArgs),
+            },
+          }
+        : call
+    );
+  }
+
+  return corrections.length ? { calls: normalizedCalls, corrections } : null;
+}
+
 export function validateToolCallBatch(toolCalls, contract, { maxToolCalls = 1 } = {}) {
   const errors = [];
   const addError = (code, callIndex, message) => {
@@ -613,6 +677,27 @@ export function resolveDispatchableToolCallBatch(toolCalls, contract) {
     };
   }
 
+  const annotationNormalization = normalizeBenignToolCallAnnotations(calls, contract);
+  if (annotationNormalization) {
+    const recovered = resolveDispatchableToolCallBatch(
+      annotationNormalization.calls,
+      contract
+    );
+    if (recovered.ok) {
+      return {
+        ...recovered,
+        recoveredToolCallAnnotations: true,
+        argumentCorrections: [
+          ...(Array.isArray(recovered.argumentCorrections)
+            ? recovered.argumentCorrections
+            : []),
+          ...annotationNormalization.corrections,
+        ],
+        originalCode: validation.code,
+      };
+    }
+  }
+
   const readRangeRecovery = recoverReadFileRangeAlias(calls, contract, validation);
   if (readRangeRecovery) return readRangeRecovery;