@possumtech/rummy 0.3.0 → 0.3.1

package/src/agent/ResponseHealer.js

@@ -1,11 +1,55 @@
 const MAX_STALLS = Number(process.env.RUMMY_MAX_STALLS) || 3;
-const MAX_REPETITIONS = Number(process.env.RUMMY_MAX_REPETITIONS) || 3;
+const MIN_CYCLES = Number(process.env.RUMMY_MIN_CYCLES) || 3;
+const MAX_CYCLE_PERIOD = Number(process.env.RUMMY_MAX_CYCLE_PERIOD) || 4;
 const MAX_UPDATE_REPEATS = Number(process.env.RUMMY_MAX_UPDATE_REPEATS) || 3;
 
+/**
+ * Build a stable fingerprint for a single recorded entry.
+ * Uses scheme + original command target + all op-defining attributes.
+ * Excludes body (content too granular; same operation ≠ same content).
+ */
+function cmdFingerprint(entry) {
+	const attrs = { ...(entry.attributes ?? {}) };
+	delete attrs.body;
+	const target =
+		attrs.path ?? attrs.command ?? attrs.query ?? attrs.question ?? "";
+	delete attrs.path;
+	const extra = Object.keys(attrs)
+		.toSorted()
+		.filter((k) => attrs[k] != null)
+		.map((k) => `${k}=${attrs[k]}`)
+		.join(",");
+	return `${entry.scheme}:${target}${extra ? `[${extra}]` : ""}`;
+}
+
+/**
+ * Detect a repeating cycle in the fingerprint history.
+ * Checks periods 1..MAX_CYCLE_PERIOD for MIN_CYCLES consecutive repetitions.
+ * Catches AAAA (period 1), ABABAB (period 2), ABCABCABC (period 3), etc.
+ */
+function detectCycle(history) {
+	for (let k = 1; k <= MAX_CYCLE_PERIOD; k++) {
+		const needed = k * MIN_CYCLES;
+		if (history.length < needed) continue;
+		const tail = history.slice(-needed);
+		const cycle = tail.slice(0, k);
+		let match = true;
+		outer: for (let rep = 0; rep < MIN_CYCLES; rep++) {
+			for (let j = 0; j < k; j++) {
+				if (tail[rep * k + j] !== cycle[j]) {
+					match = false;
+					break outer;
+				}
+			}
+		}
+		if (match) return { detected: true, period: k, cycles: MIN_CYCLES };
+	}
+	return { detected: false };
+}
+
 export default class ResponseHealer {
 	#stallCount = 0;
-	#lastFingerprint = null;
-	#repetitionCount = 0;
+	#turnHistory = [];
 	#lastUpdateText = null;
 	#updateRepeatCount = 0;
 
@@ -52,38 +96,28 @@ export default class ResponseHealer {
 	}
 
 	/**
-	 * Check for repeated tool commands across turns.
+	 * Detect cyclic tool patterns across turns.
 	 * Returns { continue: boolean, reason?: string }
 	 *
-	 * Fingerprints the commands (name + path/query). If the same fingerprint
-	 * repeats for MAX_REPETITIONS consecutive turns, force-complete.
+	 * Appends this turn's fingerprint to history, then checks whether the
+	 * history ends in a repeating cycle of period 1..MAX_CYCLE_PERIOD with
+	 * at least MIN_CYCLES consecutive repetitions.
+	 *
+	 * Catches AAAA (period 1), ABABAB (period 2), ABCABC (period 3), etc.
+	 * Turns with no tool calls are skipped — they don't contribute to a cycle.
 	 */
 	assessRepetition({ actionCalls, writeCalls }) {
 		const commands = [...(actionCalls || []), ...(writeCalls || [])];
-		if (commands.length === 0) {
-			this.#lastFingerprint = null;
-			this.#repetitionCount = 0;
-			return { continue: true };
-		}
+		if (commands.length === 0) return { continue: true };
 
-		const fingerprint = commands
-			.map((c) => `${c.name}:${c.path || c.command || c.question || ""}`)
-			.toSorted()
-			.join("|");
-
-		if (fingerprint === this.#lastFingerprint) {
-			this.#repetitionCount++;
-			if (this.#repetitionCount >= MAX_REPETITIONS) {
-				const reason = `Same commands repeated ${this.#repetitionCount} turns`;
-				console.warn(`[RUMMY] Loop detected: ${reason}. Force-completing.`);
-				return { continue: false, reason };
-			}
-			console.warn(
-				`[RUMMY] Repeated commands (${this.#repetitionCount}/${MAX_REPETITIONS}): ${fingerprint.slice(0, 80)}`,
-			);
-		} else {
-			this.#repetitionCount = 1;
-			this.#lastFingerprint = fingerprint;
+		const fp = commands.map(cmdFingerprint).toSorted().join("|");
+		this.#turnHistory.push(fp);
+
+		const cycle = detectCycle(this.#turnHistory);
+		if (cycle.detected) {
+			const reason = `Cyclic tool pattern (period ${cycle.period}, ${cycle.cycles} repetitions)`;
+			console.warn(`[RUMMY] Loop detected: ${reason}. Force-completing.`);
+			return { continue: false, reason };
 		}
 
 		return { continue: true };
@@ -96,6 +130,7 @@ export default class ResponseHealer {
 	 *
 	 * Rules:
 	 *   <summarize/> present → done (terminate)
+	 *   <summarize/> + failed actions → overridden to <update> (continue)
 	 *   <update/> present  → continue (model says it's working)
 	 *   neither present    → warn, increment stall counter, continue
 	 *   stall counter hits MAX_STALLS → force-complete
@@ -146,8 +181,7 @@ export default class ResponseHealer {
 	 */
 	reset() {
 		this.#stallCount = 0;
-		this.#lastFingerprint = null;
-		this.#repetitionCount = 0;
+		this.#turnHistory = [];
 		this.#lastUpdateText = null;
 		this.#updateRepeatCount = 0;
 	}