reasonix 0.23.0 → 0.23.1

package/dist/index.d.ts

@@ -631,6 +631,7 @@ declare class CacheFirstLoop {
     private _escalateThisTurn;
     private _turnFailureCount;
     private _turnFailureTypes;
+    private _turnSelfCorrected;
     constructor(opts: CacheFirstLoopOptions);
     /** Shrink huge edit_file/write_file args post-dispatch — tool result already explains. */
     private compactToolCallArgsAfterResponse;
@@ -642,6 +643,8 @@ declare class CacheFirstLoop {
         charsSaved: number;
     };
     appendAndPersist(message: ChatMessage): void;
+    /** Swap the just-appended assistant entry — used by self-correction to restore the original tool_calls without dropping reasoning_content. */
+    private replaceTailAssistantMessage;
     /** "New chat" — drops messages but keeps session + immutable prefix (cache-first invariant). */
     clearLog(): {
         dropped: number;

package/dist/index.js

@@ -1573,7 +1573,7 @@ var StormBreaker = class {
     if (count >= this.threshold - 1) {
       return {
         suppress: true,
-        reason: `call-storm suppressed: ${name} called with identical args ${count + 1} times within window=${this.windowSize}`
+        reason: `${name} called with identical args ${count + 1} times \u2014 repeat-loop guard tripped`
       };
     }
     this.recent.push({ name, args, readOnly });
@@ -1858,6 +1858,7 @@ var CacheFirstLoop = class {
   _escalateThisTurn = false;
   _turnFailureCount = 0;
   _turnFailureTypes = {};
+  _turnSelfCorrected = false;
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -1902,7 +1903,12 @@ var CacheFirstLoop = class {
       }
       return def.readOnly !== true;
     };
-    this.repair = new ToolCallRepair({ allowedToolNames: allowedNames, isMutating });
+    this.repair = new ToolCallRepair({
+      allowedToolNames: allowedNames,
+      isMutating,
+      stormThreshold: parsePositiveIntEnv(process.env.REASONIX_STORM_THRESHOLD),
+      stormWindow: parsePositiveIntEnv(process.env.REASONIX_STORM_WINDOW)
+    });
     this.sessionName = opts.session ?? null;
     if (this.sessionName) {
       const prior = loadSessionMessages(this.sessionName);
@@ -1984,6 +1990,21 @@ var CacheFirstLoop = class {
       }
     }
   }
+  /** Swap the just-appended assistant entry — used by self-correction to restore the original tool_calls without dropping reasoning_content. */
+  replaceTailAssistantMessage(message) {
+    const entries = this.log.entries;
+    const tail = entries[entries.length - 1];
+    if (!tail || tail.role !== "assistant") return;
+    const kept = entries.slice(0, -1);
+    kept.push(message);
+    this.log.compactInPlace(kept);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, kept);
+      } catch {
+      }
+    }
+  }
   /** "New chat" — drops messages but keeps session + immutable prefix (cache-first invariant). */
   clearLog() {
     const dropped = this.log.length;
@@ -2084,7 +2105,7 @@ var CacheFirstLoop = class {
     if (repair) {
       if (repair.scavenged > 0) bump("scavenged", repair.scavenged);
       if (repair.truncationsFixed > 0) bump("truncated", repair.truncationsFixed);
-      if (repair.stormsBroken > 0) bump("storm-broken", repair.stormsBroken);
+      if (repair.stormsBroken > 0) bump("repeat-loop", repair.stormsBroken);
     }
     if (bumped && !this._escalateThisTurn && this.autoEscalate && this._turnFailureCount >= FAILURE_ESCALATION_THRESHOLD) {
       this._escalateThisTurn = true;
@@ -2154,6 +2175,7 @@ var CacheFirstLoop = class {
     this.repair.resetStorm();
     this._turnFailureCount = 0;
     this._turnFailureTypes = {};
+    this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     let armedConsumed = false;
     if (this._proArmedForNextTurn) {
@@ -2505,10 +2527,35 @@ var CacheFirstLoop = class {
           content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this.formatFailureBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
         };
       }
+      const allSuppressed = report.stormsBroken > 0 && repairedCalls.length === 0 && toolCalls.length > 0;
+      if (allSuppressed && !this._turnSelfCorrected) {
+        this._turnSelfCorrected = true;
+        this.replaceTailAssistantMessage(
+          this.assistantMessage(
+            assistantContent,
+            toolCalls,
+            this.modelForCurrentCall(),
+            reasoningContent
+          )
+        );
+        for (const call of toolCalls) {
+          this.appendAndPersist({
+            role: "tool",
+            tool_call_id: call.id ?? "",
+            name: call.function?.name ?? "",
+            content: "[repeat-loop guard] this call was suppressed because it was identical to a previous call in this turn. Earlier results for it are above \u2014 try a meaningfully different approach, or stop and answer if you have enough."
+          });
+        }
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: "Caught a repeated tool call \u2014 let the model see the issue and retry with a different approach."
+        };
+        continue;
+      }
       if (report.stormsBroken > 0) {
         const noteTail = report.notes.length ? ` \u2014 ${report.notes[report.notes.length - 1]}` : "";
-        const allSuppressed = repairedCalls.length === 0 && toolCalls.length > 0;
-        const phrase = allSuppressed ? `stopped the model from calling the same tool with identical args repeatedly (all ${toolCalls.length} call(s) this turn were already in the recent-repeat window). Likely a stuck retry \u2014 reword your instruction, rule out the underlying blocker, or try /retry after fixing it` : `suppressed ${report.stormsBroken} repeat tool call(s) that had fired 3+ times with identical args in a sliding window`;
+        const phrase = allSuppressed ? "Stopped a stuck retry loop \u2014 the model kept calling the same tool with identical args after a self-correction nudge. Try /retry, rephrase, or rule out the underlying blocker." : `Suppressed ${report.stormsBroken} repeated tool call(s) \u2014 same name + args fired 3+ times.`;
         yield {
           turn: this._turn,
           role: "warning",
@@ -2516,7 +2563,6 @@ var CacheFirstLoop = class {
         };
       }
       if (repairedCalls.length === 0) {
-        const allSuppressed = report.stormsBroken > 0 && toolCalls.length > 0;
         if (allSuppressed) {
           yield* this.forceSummaryAfterIterLimit({ reason: "stuck" });
           return;
@@ -2741,6 +2787,11 @@ function stripHallucinatedToolMarkup(s) {
   out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
   return out.trim();
 }
+function parsePositiveIntEnv(raw) {
+  if (!raw) return void 0;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
 function safeParseToolArgs(raw) {
   try {
     return JSON.parse(raw);