@atlasharness/atlascode 0.1.89 → 0.1.90

package/dist/cli.js

@@ -20659,6 +20659,61 @@ var init_attachmentProjection = __esm(() => {
   ]);
 });
 
+// src/modelprovider/toolPairing.ts
+function ensureToolResultPairing(messages) {
+  const knownCallIds = new Set;
+  for (const m of messages) {
+    if (m?.role === "assistant" && Array.isArray(m.tool_calls)) {
+      for (const c of m.tool_calls) {
+        if (typeof c?.id === "string")
+          knownCallIds.add(c.id);
+      }
+    }
+  }
+  const strippedOrphanToolCallIds = [];
+  const kept = [];
+  for (const m of messages) {
+    if (m?.role === "tool") {
+      const id = m.tool_call_id;
+      if (typeof id !== "string" || !knownCallIds.has(id)) {
+        strippedOrphanToolCallIds.push(typeof id === "string" ? id : "");
+        continue;
+      }
+    }
+    kept.push(m);
+  }
+  const syntheticToolCallIds = [];
+  const out = [];
+  for (let i = 0;i < kept.length; i++) {
+    const m = kept[i];
+    out.push(m);
+    if (m?.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const covered = new Set;
+      for (let j = i + 1;j < kept.length; j++) {
+        if (kept[j]?.role === "assistant")
+          break;
+        if (kept[j]?.role === "tool" && typeof kept[j].tool_call_id === "string") {
+          covered.add(kept[j].tool_call_id);
+        }
+      }
+      const missing = m.tool_calls.filter((c) => typeof c?.id === "string" && !covered.has(c.id));
+      for (const c of missing) {
+        out.push({ role: "tool", tool_call_id: c.id, content: SYNTHETIC_TOOL_RESULT_CONTENT });
+        syntheticToolCallIds.push(c.id);
+      }
+    }
+  }
+  if (syntheticToolCallIds.length > 0 || strippedOrphanToolCallIds.length > 0) {
+    logForDebugging(`ensureToolResultPairing repaired wire at projection exit: +${syntheticToolCallIds.length} synthetic result(s) [${syntheticToolCallIds.join(",")}] -${strippedOrphanToolCallIds.length} orphan result(s) [${strippedOrphanToolCallIds.join(",")}]`, { level: "warn" });
+    return { messages: out, syntheticToolCallIds, strippedOrphanToolCallIds };
+  }
+  return { messages, syntheticToolCallIds, strippedOrphanToolCallIds };
+}
+var SYNTHETIC_TOOL_RESULT_CONTENT = "[tool result missing from conversation history — synthesized to preserve tool_calls/tool_result pairing. The original result was lost to compaction, resume truncation, or a malformed transcript; treat the tool as having failed and proceed.]";
+var init_toolPairing = __esm(() => {
+  init_shared();
+});
+
 // node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -27445,7 +27500,7 @@ function toOpenAIMessages(messages) {
       }
     }
   }
-  return out;
+  return ensureToolResultPairing(out).messages;
 }
 function isZodV4Instance(x) {
   return typeof x === "object" && x !== null && typeof x._zod === "object";
@@ -27566,6 +27621,7 @@ var init_params = __esm(() => {
   init_roles7();
   init_shared();
   init_attachmentProjection();
+  init_toolPairing();
   init_schema();
   init_effort();
 });
@@ -80574,6 +80630,14 @@ async function executeToolUse(tu, assistantMsg, deps) {
     toolUseResult = hookDenyText;
     supplemental = undefined;
   }
+  if (deps.repeatToolTracker) {
+    const reminder = deps.repeatToolTracker.observe(tu.name, callInput);
+    if (reminder && block.is_error !== true) {
+      const notice = createUserMessage({ content: reminder, isMeta: true });
+      notice.sourceToolUseId = tu.id;
+      supplemental = [...supplemental ?? [], notice];
+    }
+  }
   return {
     block,
     isError,
@@ -80629,10 +80693,73 @@ var init_toolOrchestration = __esm(() => {
   init_toolExecution();
 });
 
+// src/engine/pipeline/repeatToolReminder.ts
+function validateConfig(config) {
+  if (!Array.isArray(config.thresholds) || config.thresholds.length === 0) {
+    throw new Error("repeat-tool-reminder config: thresholds must be a non-empty array");
+  }
+  for (const t of config.thresholds) {
+    if (!Number.isInteger(t) || t < 2) {
+      throw new Error(`repeat-tool-reminder config: thresholds must be integers >= 2 (got ${String(t)})`);
+    }
+  }
+  if (new Set(config.thresholds).size !== config.thresholds.length) {
+    throw new Error(`repeat-tool-reminder config: thresholds must not contain duplicates (got ${config.thresholds.join(",")})`);
+  }
+  if (!Number.isInteger(config.argumentsPreviewChars) || config.argumentsPreviewChars <= 0) {
+    throw new Error(`repeat-tool-reminder config: argumentsPreviewChars must be a positive integer (got ${String(config.argumentsPreviewChars)})`);
+  }
+}
+function canonicalizeArguments(input) {
+  const sortValue = (v) => {
+    if (Array.isArray(v))
+      return v.map(sortValue);
+    if (typeof v === "object" && v !== null) {
+      const rec = v;
+      const keys = Object.keys(rec).sort();
+      const out = {};
+      for (const k of keys)
+        out[k] = sortValue(rec[k]);
+      return out;
+    }
+    return v;
+  };
+  return JSON.stringify(sortValue(input ?? null));
+}
+function createRepeatToolCallTracker(config) {
+  const resolved = {
+    thresholds: config?.thresholds ?? [...REPEAT_TOOL_REMINDER_THRESHOLDS],
+    argumentsPreviewChars: config?.argumentsPreviewChars ?? REPEAT_TOOL_REMINDER_PREVIEW_CHARS
+  };
+  validateConfig(resolved);
+  const chains = new Map;
+  return {
+    observe(toolName, input) {
+      const key = `${toolName}\x00${canonicalizeArguments(input)}`;
+      const count = (chains.get(key) ?? 0) + 1;
+      chains.set(key, count);
+      if (!resolved.thresholds.includes(count))
+        return;
+      if (count === resolved.thresholds[0]) {
+        return REPEAT_TOOL_REMINDER_GENTLE.replaceAll("{tool}", toolName).replaceAll("{count}", String(count));
+      }
+      const preview = canonicalizeArguments(input).slice(0, resolved.argumentsPreviewChars);
+      return REPEAT_TOOL_REMINDER_DETAILED.replaceAll("{tool}", toolName).replaceAll("{count}", String(count)).replaceAll("{preview}", preview);
+    }
+  };
+}
+var REPEAT_TOOL_REMINDER_THRESHOLDS, REPEAT_TOOL_REMINDER_PREVIEW_CHARS = 500, REPEAT_TOOL_REMINDER_GENTLE, REPEAT_TOOL_REMINDER_DETAILED;
+var init_repeatToolReminder = __esm(() => {
+  REPEAT_TOOL_REMINDER_THRESHOLDS = [3, 5, 8];
+  REPEAT_TOOL_REMINDER_GENTLE = "[repeat-tool-notice] You have now called {tool} {count} times in a row with identical arguments. " + "If this repetition is intentional (e.g. polling a changing value), continue; " + "otherwise adjust the arguments or try a different approach.";
+  REPEAT_TOOL_REMINDER_DETAILED = "[repeat-tool-notice] You have now called {tool} {count} times in a row with identical arguments " + "(arguments preview: {preview}). Repeating the same call is unlikely to produce a different result — " + "change the arguments, use a different tool, or explain in your reply why another identical call is needed.";
+});
+
 // src/engine/pipeline/index.ts
 var init_pipeline = __esm(() => {
   init_toolExecution();
   init_toolOrchestration();
+  init_repeatToolReminder();
 });
 
 // src/engine/tools/toolsearch/toolSearchTool.ts
@@ -82747,6 +82874,56 @@ var init_compactPtl = __esm(() => {
   init_tools();
 });
 
+// src/engine/context/keepWindow.ts
+function collectToolUseIds(messages) {
+  const ids = new Set;
+  for (const m of messages) {
+    if (m.type !== "assistant")
+      continue;
+    const content = m.message?.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const b of content) {
+      if (b.type === "tool_use" && typeof b.id === "string")
+        ids.add(b.id);
+    }
+  }
+  return ids;
+}
+function hasOrphanToolResult(window2) {
+  const ids = collectToolUseIds(window2);
+  for (const m of window2) {
+    if (m.type !== "user")
+      continue;
+    const content = m.message?.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const b of content) {
+      if (b.type === "tool_result" && typeof b.tool_use_id === "string" && !ids.has(b.tool_use_id)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function resolvePairedKeepWindow(messages, keepRecent) {
+  if (keepRecent <= 0 || messages.length === 0) {
+    return { window: undefined, revertedFrom: undefined };
+  }
+  let start = Math.max(0, messages.length - keepRecent);
+  const originalStart = start;
+  while (hasOrphanToolResult(messages.slice(start)) && start > 0) {
+    start--;
+  }
+  if (start === 0 && hasOrphanToolResult(messages)) {
+    return { window: undefined, revertedFrom: undefined, fellBackToFull: true };
+  }
+  return {
+    window: messages.slice(start),
+    revertedFrom: start !== originalStart ? originalStart : undefined
+  };
+}
+
 // src/engine/context/compactPorts.ts
 function setCompactPorts(next) {
   ports2 = next;
@@ -82886,7 +83063,14 @@ async function trimmedCompactConversation(messages, deps, customInstructions) {
     throw new Error("Failed to generate conversation summary - response did not contain valid text content");
   }
   const keepRecent = deps.keepRecent ?? 0;
-  const messagesToKeep = keepRecent > 0 ? messages.slice(-keepRecent) : undefined;
+  const keepWindow = resolvePairedKeepWindow(messages, keepRecent);
+  if (keepWindow.fellBackToFull) {
+    logForDebugging("compaction keepRecent cut fell back to full compaction: whole sequence is malformed (orphan tool_result at sequence head, tool_use unresolvable) — messagesToKeep=undefined per pre-registered §5.5 row F", { level: "warn" });
+  }
+  if (keepWindow.revertedFrom !== undefined) {
+    logForDebugging(`compaction keepRecent cut reverted to assistant round boundary: slice start ${keepWindow.revertedFrom} → ${messages.length - keepWindow.window.length} (kept ${keepWindow.window.length} messages)`, { level: "info" });
+  }
+  const messagesToKeep = keepWindow.window;
   const summaryMessages = [
     {
       type: "user",
@@ -83018,7 +83202,14 @@ async function richCompactConversation(messages, context, cacheSafeParams, suppr
         preCompactDiscoveredTools: [...preCompactDiscovered].sort()
       };
     }
-    const messagesToKeep = keepRecent > 0 ? messages.slice(-keepRecent) : undefined;
+    const keepWindow = resolvePairedKeepWindow(messages, keepRecent);
+    if (keepWindow.fellBackToFull) {
+      logForDebugging("compaction keepRecent cut fell back to full compaction: whole sequence is malformed (orphan tool_result at sequence head, tool_use unresolvable) — messagesToKeep=undefined per pre-registered §5.5 row F", { level: "warn" });
+    }
+    if (keepWindow.revertedFrom !== undefined) {
+      logForDebugging(`compaction keepRecent cut reverted to assistant round boundary: slice start ${keepWindow.revertedFrom} → ${messages.length - keepWindow.window.length} (kept ${keepWindow.window.length} messages)`, { level: "info" });
+    }
+    const messagesToKeep = keepWindow.window;
     const transcriptPath = getTranscriptPath();
     const summaryMessages = [
       {
@@ -84186,7 +84377,8 @@ async function queryOneRound(deps, tools, messages) {
     hooks: deps.hooks?.toolHooks,
     toolContext: deps.toolContext,
     onToolHeartbeat: deps.emit ? (info) => deps.emit({ type: "tool_heartbeat", ...info }) : undefined,
-    onMcpToolBackgrounded: deps.onMcpToolBackgrounded
+    onMcpToolBackgrounded: deps.onMcpToolBackgrounded,
+    repeatToolTracker: deps.repeatToolTracker
   });
   const deferredOutcome = outcomes.find((o) => o.deferred);
   const deferredPayload = deferredOutcome ? {
@@ -84240,6 +84432,7 @@ async function queryAgentLoop(deps, args) {
   const maxGoalTurns = args.context?.maxGoalTurns ?? DEFAULT_MAX_GOAL_TURNS;
   let goalTurns = 0;
   let deferredToolUse;
+  deps = { ...deps, repeatToolTracker: createRepeatToolCallTracker() };
   if (deps.transcript) {
     await deps.transcript.record(messages);
     if (isCompactBoundaryMessage(messages[0])) {
@@ -84472,6 +84665,7 @@ var init_loop = __esm(() => {
   init_goalState();
   init_hooksConfig();
   init_pipeline();
+  init_repeatToolReminder();
   init_context();
   init_reactiveCompactError();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlasharness/atlascode",
-  "version": "0.1.89",
+  "version": "0.1.90",
   "description": "AtlasCode \u2014 Coding Agent for the domestic computing ecosystem (Ascend NPU + domestic LLM backends)",
   "homepage": "https://www.atlaswork.cn/",
   "bin": {