@lazyingart/agintiflow 0.20.284 → 0.20.286

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.284",
+  "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",
@@ -180,6 +180,7 @@
     "smoke:localllm-model-tiers": "node scripts/smoke-localllm-model-tiers.js",
     "smoke:localllm-provider": "node scripts/smoke-localllm-provider.js",
     "smoke:progressive-tools": "node scripts/smoke-progressive-tool-selection.js",
+    "smoke:scoped-artifact-research": "node scripts/smoke-scoped-artifact-research.js",
     "smoke:truthful-completion": "node scripts/smoke-truthful-completion.js",
     "smoke:document-artifact-quality": "node scripts/smoke-document-artifact-quality.js",
     "smoke:writing-specialist-routing": "node scripts/smoke-writing-specialist-routing.js",

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/progressive-tool-selection.js

@@ -2440,11 +2440,10 @@ export function selectProgressiveTools(
 
   if (config.scopedArtifactTask === true && config.scopedArtifactRoot) {
     const available = new Map(enabled.map(({ name, tool }) => [name, tool]));
-    return [
+    const scopedWorkspaceTools = [
       constrainScopedArtifactPath(
         available.get("list_files"),
-        config.scopedArtifactRoot,
-        { rootOnly: true }
+        config.scopedArtifactRoot
       ),
       constrainScopedArtifactPath(
         available.get("read_file"),
@@ -2452,8 +2451,7 @@ export function selectProgressiveTools(
       ),
       constrainScopedArtifactPath(
         available.get("search_files"),
-        config.scopedArtifactRoot,
-        { rootOnly: true }
+        config.scopedArtifactRoot
       ),
       constrainScopedArtifactPath(
         available.get("write_file"),
@@ -2464,8 +2462,40 @@ export function selectProgressiveTools(
         config.scopedArtifactRoot
       ),
       available.get("run_command"),
-      finish,
     ].filter(Boolean);
+
+    // Artifact isolation limits where the task may read or write; it must not
+    // erase the task's research, browser, or specialist capabilities. Keep
+    // inferred non-file tools while the workspace tools remain root-scoped.
+    const scopedWorkspaceToolNames = new Set(
+      scopedWorkspaceTools.map((tool) => openAiFunctionName(tool)).filter(Boolean)
+    );
+    const taskSpecificTools = compactToolNames({ config, goal, profile, messages })
+      .filter((name) => name !== "finish" && !FILE_TOOL_NAMES.has(name))
+      .filter((name) => !scopedWorkspaceToolNames.has(name))
+      .map((name) => available.get(name))
+      .filter(Boolean);
+    const requestedLimit = finitePositiveInteger(
+      config.toolSurfaceMaxTools ?? config.localToolMaxTools,
+      DEFAULT_LOCAL_TOOL_LIMIT
+    );
+    const toolLimit = Math.min(requestedLimit, LOCAL_TOOL_HARD_CAP);
+    const taskSpecificLimit = Math.max(
+      0,
+      toolLimit - scopedWorkspaceTools.length - 1
+    );
+    const selected = [];
+    const seen = new Set();
+    for (const tool of [
+      ...taskSpecificTools.slice(0, taskSpecificLimit),
+      ...scopedWorkspaceTools,
+    ]) {
+      const name = openAiFunctionName(tool);
+      if (!name || name === "finish" || seen.has(name) || selected.length + 1 >= toolLimit) continue;
+      seen.add(name);
+      selected.push(tool);
+    }
+    return [...selected, finish];
   }
 
   if (config.repositoryGroundingRequired === true) {

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;