@lazyingart/agintiflow 0.20.329 → 0.20.330

package/docs/supervision-campaign-ledger.md

@@ -700,3 +700,24 @@ status" prompt, triggers a DeepSeek quota handoff, and verifies that LocalLLM is
 called only after compaction. The run completes without `session.failed`, keeps
 the provider handoff active on the same session, and records the compaction
 events as durable evidence.
+
+### Harmless tool-call annotations during repository discovery
+
+`inspect-project-annotation-093` covers a DeepSeek-first tool-loop boundary
+that was still under-tested after the provider handoff work. Recent runtime
+evidence showed ordinary project-inspection tasks stopping with
+`tool_contract_violation` before dispatch because the model included a
+non-executable `reason` field in an otherwise valid `inspect_project` call.
+The strict per-turn schema correctly rejected unknown executable fields, but
+the existing benign-annotation normalizer only recognized `description`.
+
+AgInTiFlow now treats a bounded string `reason` exactly like `description`: it
+is removed before schema validation only when the offered tool schema forbids
+additional properties and the schema does not define that field. Structured,
+non-string, oversized, or executable unknown fields still fail closed.
+
+The regression uses a normal weak prompt asking the agent to look over a small
+repository and report whether a README exists. The scripted DeepSeek-shaped
+response calls `inspect_project` with `reason` plus a real `limit`; the persisted
+runtime dispatches the inspection, records zero tool-contract failures, and
+finishes with the verified README status without mutating the workspace.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.329",
+  "version": "0.20.330",
   "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-progressive-tool-selection.js

@@ -7238,6 +7238,54 @@ assert(
   ).ok,
   "valid offered tool call did not satisfy its exact schema"
 );
+const strictInspectDescriptor = {
+  type: "function",
+  function: {
+    name: "inspect_project",
+    description: "Inspect the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        maxDepth: { type: "integer" },
+        limit: { type: "integer" },
+        includeFiles: { type: "boolean" },
+      },
+      additionalProperties: false,
+    },
+  },
+};
+const recoveredInspectReason = resolveDispatchableToolCallBatch(
+  [
+    contractCall("inspect-with-reason", "inspect_project", {
+      reason: "Orient before answering the user's project question.",
+      limit: 120,
+    }),
+  ],
+  createToolContract([strictInspectDescriptor])
+);
+assert(
+  recoveredInspectReason.ok && recoveredInspectReason.recoveredToolCallAnnotations,
+  "a harmless inspect_project reason annotation was not stripped before schema validation"
+);
+assertStrict.deepEqual(
+  JSON.parse(recoveredInspectReason.acceptedToolCalls[0].function.arguments),
+  { limit: 120 },
+  "inspect_project reason annotation recovery changed executable arguments"
+);
+const rejectedStructuredInspectReason = resolveDispatchableToolCallBatch(
+  [
+    contractCall("inspect-structured-reason", "inspect_project", {
+      reason: { intent: "orient" },
+      limit: 120,
+    }),
+  ],
+  createToolContract([strictInspectDescriptor])
+);
+assert(
+  !rejectedStructuredInspectReason.ok,
+  "a structured inspect_project reason annotation was stripped even though it is not a bounded text note"
+);
 
 const safeReadDescriptors = [
   {
@@ -7877,6 +7925,73 @@ assert(
   "authoritative routine flow still dispatched private/raw exploratory commands"
 );
 
+let annotatedInspectStep = 0;
+const annotatedInspectRun = await runToolContractCase({
+  id: "inspect-project-reason-annotation",
+  provider: "deepseek",
+  profile: "code",
+  goal: "Please look over this little repo and tell me whether it has a README. Keep it short.",
+  toolCalls: [
+    contractCall("unused-annotated-inspect", "finish", { result: "unused" }),
+  ],
+  expectSuccess: true,
+  expectedContractFailures: 0,
+  setupWorkspace: async (workspace) => {
+    await fs.writeFile(
+      path.join(workspace, "README.md"),
+      "# Demo\nThis workspace has a README.\n",
+      "utf8"
+    );
+  },
+  responseFactory: ({ payload }) => {
+    annotatedInspectStep += 1;
+    const offered = Array.isArray(payload.tools) ? names(payload.tools) : [];
+    if (annotatedInspectStep === 1) {
+      assert(
+        offered.includes("inspect_project"),
+        "normal repository orientation did not offer inspect_project"
+      );
+      return assistantWithToolCalls([
+        contractCall("inspect-with-natural-reason", "inspect_project", {
+          reason: "Orient before answering the user's project question.",
+          limit: 120,
+        }),
+      ]);
+    }
+    return assistantWithToolCalls([
+      contractCall("finish-after-annotated-inspect", "finish", {
+        result: "README.md is present.",
+      }),
+    ]);
+  },
+});
+assertStrict.equal(
+  annotatedInspectRun.requests.length,
+  2,
+  "annotated inspect_project recovery used extra model turns"
+);
+assert(
+  annotatedInspectRun.events.some(
+    (event) =>
+      event.type === "tool.completed" &&
+      event.data?.toolName === "inspect_project" &&
+      event.data?.ok === true
+  ),
+  "annotated inspect_project call was not dispatched through the real runtime"
+);
+assert(
+  !annotatedInspectRun.events.some(
+    (event) =>
+      event.type === "tool.failed" &&
+      event.data?.category === "tool-contract-violation"
+  ),
+  "annotated inspect_project still produced a tool-contract violation"
+);
+assert(
+  /README\.md is present/.test(String(annotatedInspectRun.result?.result || "")),
+  "annotated inspect_project run did not finish with the promised repository status"
+);
+
 const hiddenDryRun = await runToolContractCase({
   id: "native-hidden-dry-run",
   goal: "Create hidden-dry-run.txt containing unsafe if this tool dispatches.",

package/src/tool-contract.js

@@ -30,7 +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"]);
+const BENIGN_TOOL_CALL_ANNOTATION_KEYS = new Set(["description", "reason"]);
 
 function cloneValue(value) {
   return structuredClone(value);