@lazyingart/agintiflow 0.20.202 → 0.20.203

package/docs/labcanvas-chatops-fallback.md

@@ -26,11 +26,31 @@ AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"chat-response","request":"Produce only the
 
 or:
 
+```text
+AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"host-managed-response","request":"Return the report body; LabCanvas compiles and delivers it."}
+```
+
+or:
+
 ```text
 AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Create the requested PDF from the supplied evidence."}
 ```
 
-For `chat-response`, ordinary conversation and routing do not require file or command evidence. For `task`, evidence requirements are inferred only from the exact request, not from surrounding wrapper prose. Artifact requests still require real artifacts.
+For `chat-response`, ordinary conversation and routing do not require file or command evidence. `host-managed-response` is for content-only subtasks such as a LaTeX body, translation, completion audit, or scheduled lesson where LabCanvas owns persistence, compilation, validation, and delivery. For `task`, evidence requirements are inferred only from the exact request, not from surrounding wrapper prose. Artifact requests still require real artifacts.
+
+## Provider Tool-Batch Recovery
+
+AgInTi requests one effectful tool call at a time, but some OpenAI-compatible
+providers may still emit a small batch. A bounded batch of otherwise valid
+calls is handled sequentially: AgInTi dispatches only the first call, records
+`tool.batch_deferred`, and asks the model to continue from the resulting state.
+Deferred calls are never executed automatically. Per-tool schema, permission,
+secret, path, and irreversible-action checks remain authoritative.
+
+Malformed calls, duplicate IDs, unavailable tools, hidden arguments, or an
+oversized batch still stop with `tool_contract_violation`. A host may resume
+the same saved session with another provider after that categorized stop; it
+must not replay the original request or duplicate earlier side effects.
 
 ## Local Context Recovery
 
@@ -43,4 +63,3 @@ npm run check
 npm run smoke:context-budget-recovery
 npm run smoke:truthful-completion
 ```
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.202",
+  "version": "0.20.203",
   "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

@@ -18,6 +18,7 @@ import { SessionStore } from "../src/session-store.js";
 import {
   attachToolContract,
   createToolContract,
+  resolveDispatchableToolCallBatch,
   safeSequentialToolBatchLimit,
   toolContractFromResponse,
   validateToolCallBatch,
@@ -888,6 +889,14 @@ assert(
   }).ok,
   "mixed read/write batch unexpectedly passed"
 );
+const recoveredMixedBatch = resolveDispatchableToolCallBatch(
+  mixedReadWriteCalls,
+  createToolContract([...safeReadDescriptors, strictWriteDescriptor])
+);
+assert(recoveredMixedBatch.ok, "valid mixed batch could not recover through bounded sequential deferral");
+assert(recoveredMixedBatch.recoveredSequentially, "mixed batch recovery was not recorded");
+assert(recoveredMixedBatch.acceptedToolCalls.length === 1, "mixed batch recovery dispatched more than one call");
+assert(recoveredMixedBatch.deferredToolCalls.length === 1, "mixed batch recovery did not defer the extra call");
 const oversizedReadCalls = Array.from({ length: 5 }, (_, index) =>
   contractCall(`read-${index}`, "read_file", { path: `file-${index}.txt` })
 );
@@ -968,6 +977,9 @@ async function runToolContractCase({
   allowShellTool = false,
   toolSurfaceMaxTools = 12,
   targets = [],
+  expectedTargets = [],
+  followupToolCalls = null,
+  expectSequentialRecovery = false,
 }) {
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), `agintiflow-tool-contract-${id}-`));
   const workspace = path.join(tempRoot, "workspace");
@@ -988,7 +1000,10 @@ async function runToolContractCase({
           if (textFallback) {
             return { choices: [{ message: { role: "assistant", content: responseText } }] };
           }
-          return assistantWithToolCalls(toolCalls);
+          const selectedToolCalls = Array.isArray(followupToolCalls) && requests.length > 1
+            ? followupToolCalls
+            : toolCalls;
+          return assistantWithToolCalls(selectedToolCalls);
         },
       },
     },
@@ -1082,6 +1097,23 @@ async function runToolContractCase({
     const events = await store.loadEvents();
     const contractFailures = events.filter((event) => event.type === "tool.failed" && event.data?.category === "tool-contract-violation");
     assert(clientFactoryCalls === 1, `${id} did not complete readiness and construct exactly one deterministic client`);
+    if (expectSequentialRecovery) {
+      assert(result.stopped !== true, `${id} stopped instead of completing the recovered sequential batch`);
+      assert(contractFailures.length === 0, `${id} recorded a contract failure for a recoverable valid batch`);
+      assert(
+        events.some((event) => event.type === "tool.batch_deferred" && event.data?.deferredCount === toolCalls.length - 1),
+        `${id} did not record bounded sequential deferral`
+      );
+      for (const target of expectedTargets) {
+        const exists = await fs.access(path.join(workspace, target)).then(() => true).catch(() => false);
+        assert(exists, `${id} did not create expected artifact ${target}`);
+      }
+      for (const target of targets) {
+        const exists = await fs.access(path.join(workspace, target)).then(() => true).catch(() => false);
+        assert(!exists, `${id} dispatched deferred artifact ${target}`);
+      }
+      return { result, requests, events, contractFailures, clientFactoryCalls };
+    }
     assert(
       result.stopped === true && result.reason === "tool_contract_violation",
       `${id} did not stop after one bounded repair: ${JSON.stringify({
@@ -1151,16 +1183,19 @@ assert(
 
 const multiCall = await runToolContractCase({
   id: "native-multi-call",
-  goal: "Create multi-one.txt and multi-two.txt.",
+  goal: "Create multi-one.txt containing safe.",
   toolCalls: [
-    contractCall("multi-one", "write_file", { path: "multi-one.txt", content: "unsafe", mode: "create" }),
-    contractCall("multi-two", "write_file", { path: "multi-two.txt", content: "unsafe", mode: "create" }),
+    contractCall("multi-one", "write_file", { path: "multi-one.txt", content: "safe", mode: "create" }),
+    contractCall("multi-two", "write_file", { path: "multi-two.txt", content: "deferred", mode: "create" }),
   ],
-  targets: ["multi-one.txt", "multi-two.txt"],
+  followupToolCalls: [contractCall("finish-recovered", "finish", { result: "Created and verified multi-one.txt." })],
+  expectSequentialRecovery: true,
+  expectedTargets: ["multi-one.txt"],
+  targets: ["multi-two.txt"],
 });
 assert(
-  multiCall.contractFailures.every((event) => event.data?.errors?.some((error) => error.code === "TOO_MANY_TOOL_CALLS")),
-  "multi-call batch did not enforce the one-call cap"
+  multiCall.events.some((event) => event.type === "tool.completed" && event.data?.toolName === "write_file"),
+  "recoverable multi-call batch did not dispatch its first valid call"
 );
 
 const duplicateId = await runToolContractCase({

package/src/agent-runner.js

@@ -96,9 +96,8 @@ import {
 } from "./step-budget-controller.js";
 import { selectExecutionPolicy } from "./execution-policy.js";
 import {
-  safeSequentialToolBatchLimit,
+  resolveDispatchableToolCallBatch,
   toolContractFromResponse,
-  validateToolCallBatch,
 } from "./tool-contract.js";
 import {
   createContextBudgetState,
@@ -3909,17 +3908,18 @@ export async function runAgent(config) {
       }
 
       const rawToolCalls = assistantMessage.tool_calls;
-      const toolCalls = Array.isArray(rawToolCalls) ? rawToolCalls : [];
+      const reportedToolCalls = Array.isArray(rawToolCalls) ? rawToolCalls : [];
       const toolBatchValidation = rawToolCalls === undefined || rawToolCalls === null
-        ? { ok: true, calls: [] }
-        : validateToolCallBatch(rawToolCalls, toolContractFromResponse(response), {
-            maxToolCalls: safeSequentialToolBatchLimit(rawToolCalls),
-          });
+        ? { ok: true, calls: [], acceptedToolCalls: [], deferredToolCalls: [] }
+        : resolveDispatchableToolCallBatch(rawToolCalls, toolContractFromResponse(response));
+      const toolCalls = toolBatchValidation.ok
+        ? (toolBatchValidation.acceptedToolCalls || reportedToolCalls)
+        : reportedToolCalls;
 
       await store.appendEvent("model.responded", {
         step,
         content: redactSensitiveText(assistantMessage.content || ""),
-        toolCalls: toolCalls.map((call) => ({
+        toolCalls: reportedToolCalls.map((call) => ({
           id: call?.id,
           name: call?.function?.name,
           arguments: redactSensitiveText(call?.function?.arguments || ""),
@@ -3962,7 +3962,27 @@ export async function runAgent(config) {
         continue;
       }
 
-      state.messages.push(preserveAssistantMessage(assistantMessage));
+      if (toolBatchValidation.recoveredSequentially) {
+        const deferredToolCalls = toolBatchValidation.deferredToolCalls || [];
+        const detail = {
+          step,
+          reportedCount: reportedToolCalls.length,
+          dispatchedCount: toolCalls.length,
+          deferredCount: deferredToolCalls.length,
+          dispatchedTool: String(toolCalls[0]?.function?.name || ""),
+          deferredTools: deferredToolCalls.map((call) => String(call?.function?.name || "")).filter(Boolean),
+        };
+        await store.appendEvent("tool.batch_deferred", detail);
+        observers.event("tool.batch_deferred", detail);
+      }
+
+      state.messages.push(
+        preserveAssistantMessage(
+          toolBatchValidation.recoveredSequentially
+            ? { ...assistantMessage, tool_calls: toolCalls }
+            : assistantMessage
+        )
+      );
 
       if (toolCalls.length === 0) {
         const queuedCount = await injectQueuedUserMessages(store, state, observers);

package/src/scs-evidence.js

@@ -519,7 +519,7 @@ function scopedChatopsEvidenceGoal(goal = "", taskProfile = "") {
     const payload = JSON.parse(match[1]);
     if (!payload || typeof payload !== "object") return String(goal || "");
     const mode = String(payload.mode || "").trim().toLowerCase();
-    if (["chat-response", "plan-response", "read-only-answer"].includes(mode)) {
+    if (["chat-response", "host-managed-response", "plan-response", "read-only-answer"].includes(mode)) {
       return "Answer the current chat turn directly without external execution.";
     }
     const request = String(payload.request || "").trim();

package/src/tool-contract.js

@@ -29,6 +29,7 @@ const SAFE_SEQUENTIAL_READ_TOOLS = new Set([
 const MAX_VALIDATION_ERRORS = 8;
 const MAX_VALIDATION_NODES = 50_000;
 const MAX_SAFE_SEQUENTIAL_READ_CALLS = 4;
+const MAX_RECOVERABLE_SEQUENTIAL_CALLS = 4;
 
 function cloneValue(value) {
   return structuredClone(value);
@@ -331,3 +332,42 @@ export function validateToolCallBatch(toolCalls, contract, { maxToolCalls = 1 }
   }
   return { ok: true, calls: parsedCalls };
 }
+
+export function resolveDispatchableToolCallBatch(toolCalls, contract) {
+  const calls = Array.isArray(toolCalls) ? toolCalls : [];
+  const validation = validateToolCallBatch(calls, contract, {
+    maxToolCalls: safeSequentialToolBatchLimit(calls),
+  });
+  if (validation.ok) {
+    return {
+      ...validation,
+      acceptedToolCalls: calls,
+      deferredToolCalls: [],
+      recoveredSequentially: false,
+    };
+  }
+
+  const errors = Array.isArray(validation.errors) ? validation.errors : [];
+  const onlyExceededBatchLimit =
+    errors.length > 0 && errors.every((error) => error?.code === "TOO_MANY_TOOL_CALLS");
+  if (
+    !onlyExceededBatchLimit ||
+    calls.length <= 1 ||
+    calls.length > MAX_RECOVERABLE_SEQUENTIAL_CALLS
+  ) {
+    return validation;
+  }
+
+  const firstCallValidation = validateToolCallBatch([calls[0]], contract, {
+    maxToolCalls: 1,
+  });
+  if (!firstCallValidation.ok) return validation;
+
+  return {
+    ...firstCallValidation,
+    acceptedToolCalls: [calls[0]],
+    deferredToolCalls: calls.slice(1),
+    recoveredSequentially: true,
+    originalCode: validation.code,
+  };
+}