@lazyingart/agintiflow 0.20.260 → 0.20.261

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.260",
+  "version": "0.20.261",
   "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-deep-research.js

@@ -175,13 +175,86 @@ async function main() {
     toolChoiceForProvider(
       { provider: "deepseek" },
       [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }]
-    ) === "auto",
-    "DeepSeek thinking mode received unsupported required tool selection during recovery"
+    ) === "required",
+    "DeepSeek action recovery did not require a tool call"
+  );
+  assert(
+    JSON.stringify(toolChoiceForProvider(
+      { provider: "deepseek" },
+      [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }],
+      [
+        { type: "function", function: { name: "apply_patch" } },
+        { type: "function", function: { name: "finish" } },
+      ]
+    )) === JSON.stringify({ type: "function", function: { name: "apply_patch" } }),
+    "DeepSeek action recovery did not force the only executable tool"
   );
   assert(
     JSON.stringify(providerStructuredOutputAttempts("deepseek")) === JSON.stringify(["json_object", "prompt"]),
     "DeepSeek structured extraction still probes an unsupported JSON Schema mode"
   );
+  let deepSeekActionPayload = null;
+  await requestNextStep(
+    {
+      chat: {
+        completions: {
+          create: async (payload) => {
+            deepSeekActionPayload = payload;
+            return {
+              choices: [{
+                message: {
+                  role: "assistant",
+                  content: "",
+                  tool_calls: [{
+                    id: "deepseek-action-patch",
+                    type: "function",
+                    function: {
+                      name: "apply_patch",
+                      arguments: JSON.stringify({
+                        path: "service.py",
+                        search: "old",
+                        replace: "new",
+                        expectedReplacements: 1,
+                      }),
+                    },
+                  }],
+                },
+              }],
+            };
+          },
+        },
+      },
+    },
+    {
+      provider: "deepseek",
+      model: "deepseek-v4-pro",
+      reasoning: "xhigh",
+      goal: "Repair service.py from exact retained source.",
+      taskProfile: "code",
+      allowFileTools: true,
+      allowShellTool: false,
+      allowWebSearch: false,
+      allowMcpTools: false,
+      allowWrapperTools: false,
+      allowAuxiliaryTools: false,
+      completionFreshMutationRequired: true,
+      completionFreshMutationNeedsSourceRead: false,
+      completionFreshMutationPaths: ["service.py"],
+    },
+    [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }]
+  );
+  assert(
+    deepSeekActionPayload?.thinking?.type === "disabled",
+    "DeepSeek reasoning-only recovery did not disable a second expensive thinking pass"
+  );
+  assert(
+    deepSeekActionPayload?.tool_choice?.function?.name === "apply_patch",
+    "DeepSeek reasoning-only recovery did not force its single executable tool"
+  );
+  assert(
+    !Object.hasOwn(deepSeekActionPayload || {}, "reasoning_effort"),
+    "DeepSeek action-only recovery sent a conflicting reasoning effort"
+  );
 
   assert(!isPublicWebUrl("http://127.0.0.1/private"), "public URL guard accepted loopback");
   assert(!isPublicWebUrl("http://10.0.0.1/private"), "public URL guard accepted RFC1918 address");

package/scripts/smoke-dynamic-step-budget.js

@@ -705,6 +705,24 @@ try {
       tracebackPacket.content.includes("### tests/test_traceback_packet.py"),
     "exact same-workspace test files named by a traceback were omitted when discovery metadata was empty"
   );
+  const repeatedTracebackPacketState = structuredClone(tracebackPacketState);
+  repeatedTracebackPacketState.meta.projectVerification.testRuns[0].failureSignature =
+    "repeated-validator-traceback-file-recovery";
+  repeatedTracebackPacketState.meta.projectVerification.testRuns[0].failureSummary =
+    [
+      `File "${path.join(workspace, "duplicate-source.py")}", line 1, in first`,
+      `File "${path.join(workspace, "duplicate-source.py")}", line 2, in second`,
+      `File "${path.join(workspace, "duplicate-source.py")}", line 3, in third`,
+      `File "${path.join(workspace, "tests", "test_traceback_packet.py")}", line 4, in test_contract`,
+    ].join("\n");
+  const repeatedTracebackPacket = await buildFailedTestRecoveryPacket(
+    { commandCwd: workspace },
+    repeatedTracebackPacketState
+  );
+  assert(
+    repeatedTracebackPacket.paths.includes("tests/test_traceback_packet.py"),
+    "duplicate frames from one validator crowded the actual failing test out of recovery evidence"
+  );
   assert(
     (await failedTestRepairPatchBlock(
       duplicateRepairState,

package/src/agent-runner.js

@@ -4777,8 +4777,8 @@ async function failedTestTracebackSourceDocuments(testRun = {}, config = {}) {
       ? path.resolve(reportedPath)
       : path.resolve(commandCwd, reportedPath);
     const line = Math.max(1, Number(match[2] || 1));
-    if (seen.has(`${absolutePath}:${line}`)) continue;
-    seen.add(`${absolutePath}:${line}`);
+    if (seen.has(absolutePath)) continue;
+    seen.add(absolutePath);
     const insideWorkspace =
       absolutePath === commandCwd || absolutePath.startsWith(`${commandCwd}${path.sep}`);
     const namedByCommand = command.includes(absolutePath);
@@ -4797,7 +4797,7 @@ async function failedTestTracebackSourceDocuments(testRun = {}, config = {}) {
     const raw = await fs.readFile(absolutePath, "utf8").catch(() => "");
     if (!raw) continue;
     documents.push({ absolutePath, line, raw });
-    if (documents.length >= 3) break;
+    if (documents.length >= 5) break;
   }
   return documents;
 }

package/src/model-client.js

@@ -134,6 +134,10 @@ function chatReasoningEffort(config = {}) {
 }
 
 function withChatReasoningEffort(payload = {}, config = {}) {
+  if (payload.thinking?.type === "disabled") {
+    const { reasoning_effort: _reasoningEffort, ...rest } = payload;
+    return rest;
+  }
   const reasoning = chatReasoningEffort(config);
   if (!reasoning) {
     const { reasoning_effort: _reasoningEffort, ...rest } = payload;
@@ -336,17 +340,35 @@ function assertLocalRequestWithinContext(payload = {}, config = {}, label = "age
 
 export { hasExplicitDeepResearchIntent } from "./research-routing.js";
 
-export function toolChoiceForProvider(config, messages = []) {
-  const requiresConcreteContinuation = messages.slice(-3).some(
+function requiresConcreteToolContinuation(messages = []) {
+  return messages.slice(-3).some(
     (message) =>
       message?.role === "user" &&
       /emit exactly one enabled tool call that performs the next concrete action/i.test(String(message.content || ""))
   );
-  // DeepSeek thinking models reject tool_choice="required" even though they
-  // accept the same native tool schema with auto selection. The continuation
-  // instruction remains explicit in the messages, so keep the supported
-  // provider mode instead of turning a recoverable truncation into HTTP 400.
-  if (requiresConcreteContinuation && normalizeProviderId(config.provider, "") !== "deepseek") {
+}
+
+function deepSeekActionOnlyRequest(config = {}, messages = []) {
+  return normalizeProviderId(config.provider, "") === "deepseek" &&
+    requiresConcreteToolContinuation(messages);
+}
+
+export function toolChoiceForProvider(config, messages = [], tools = []) {
+  const requiresConcreteContinuation = requiresConcreteToolContinuation(messages);
+  if (requiresConcreteContinuation) {
+    const actionable = (Array.isArray(tools) ? tools : [])
+      .filter((tool) => tool?.type === "function" && tool.function?.name !== "finish")
+      .map((tool) => String(tool.function?.name || ""))
+      .filter(Boolean);
+    if (
+      normalizeProviderId(config.provider, "") === "deepseek" &&
+      actionable.length === 1
+    ) {
+      return {
+        type: "function",
+        function: { name: actionable[0] },
+      };
+    }
     return "required";
   }
   if (config.provider !== "venice") return "auto";
@@ -2649,10 +2671,13 @@ export async function requestNextStep(client, config, messages) {
   const nativePayload = {
     model: config.model,
     temperature: 0,
-    tool_choice: toolChoiceForProvider(config, messages),
+    tool_choice: toolChoiceForProvider(config, messages, requestTools),
     parallel_tool_calls: false,
     messages: prepareMessages(config, messages),
     tools: requestTools,
+    ...(deepSeekActionOnlyRequest(config, messages)
+      ? { thinking: { type: "disabled" } }
+      : {}),
     ...(Number(config.maxOutputTokens || 0) > 0 ? { max_tokens: Number(config.maxOutputTokens) } : {}),
   };
   const textPayload = {

package/src/provider-contract.js

@@ -75,7 +75,7 @@ export const PROVIDER_CONTRACTS = Object.freeze({
     defaultModel: "deepseek-v4-flash",
     toolProtocol: "native",
     structuredOutput: "json_object",
-    supportsReasoningEffort: false,
+    supportsReasoningEffort: true,
     textToolFallback: false,
   }),
   openai: Object.freeze({