@mindstudio-ai/remy 0.1.329 → 0.1.330

package/dist/headless.js

@@ -100,6 +100,87 @@ function resolveConfig(flags) {
   return { apiKey, baseUrl: baseUrl2, appId };
 }
 
+// src/loopGuard.ts
+var PARAGRAPH_REPEAT_THRESHOLD = 6;
+var MIN_PARAGRAPH_CHARS = 80;
+var CHUNK_SIZE = 60;
+var CHUNK_WINDOW = 5e3;
+var CHUNK_REPEAT_THRESHOLD = 10;
+var LONE_HEADER = /^\*{1,3}[^*].*\*{1,3}$/;
+function normalizeParagraph(seg) {
+  const trimmed = seg.trim();
+  if (!trimmed || LONE_HEADER.test(trimmed)) {
+    return null;
+  }
+  const key = trimmed.toLowerCase().replace(/\s+/g, " ");
+  if (key.length < MIN_PARAGRAPH_CHARS) {
+    return null;
+  }
+  return key;
+}
+var RepetitionDetector = class {
+  // Paragraph detector: incomplete tail awaiting its closing blank line, plus
+  // occurrence counts of completed, normalized paragraphs.
+  paragraphBuffer = "";
+  paragraphCounts = /* @__PURE__ */ new Map();
+  // Rolling-chunk detector: the trailing window of raw fed text.
+  window = "";
+  fired = false;
+  /**
+   * Feed the next streamed text fragment. Returns a signal the first time a
+   * loop is recognized, then null forever after (the caller aborts on the
+   * first signal; further feeds are harmless no-ops).
+   */
+  feed(text) {
+    if (this.fired || !text) {
+      return null;
+    }
+    return this.feedParagraphs(text) ?? this.feedChunks(text);
+  }
+  feedParagraphs(text) {
+    this.paragraphBuffer += text;
+    const segments = this.paragraphBuffer.split(/\n\s*\n/);
+    this.paragraphBuffer = segments.pop() ?? "";
+    for (const seg of segments) {
+      const key = normalizeParagraph(seg);
+      if (!key) {
+        continue;
+      }
+      const count = (this.paragraphCounts.get(key) ?? 0) + 1;
+      this.paragraphCounts.set(key, count);
+      if (count >= PARAGRAPH_REPEAT_THRESHOLD) {
+        this.fired = true;
+        return {
+          kind: "paragraph",
+          repeats: count,
+          sample: seg.trim().slice(0, 160)
+        };
+      }
+    }
+    return null;
+  }
+  feedChunks(text) {
+    this.window = (this.window + text).slice(-CHUNK_WINDOW);
+    if (this.window.length < CHUNK_SIZE * CHUNK_REPEAT_THRESHOLD) {
+      return null;
+    }
+    const tail = this.window.slice(-CHUNK_SIZE);
+    if (!tail.trim()) {
+      return null;
+    }
+    const occurrences = this.window.split(tail).length - 1;
+    if (occurrences >= CHUNK_REPEAT_THRESHOLD) {
+      this.fired = true;
+      return {
+        kind: "chunk",
+        repeats: occurrences,
+        sample: tail.replace(/\s+/g, " ").trim().slice(0, 160)
+      };
+    }
+    return null;
+  }
+};
+
 // src/api.ts
 var log2 = createLogger("api");
 async function* streamChat(params) {
@@ -311,17 +392,51 @@ async function* streamChatWithRetry(params, options) {
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const buffer = [];
     let retryableFailure = false;
-    for await (const event of streamChat(params)) {
-      if (event.type === "error") {
-        if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
-          options?.onRetry?.(attempt, event.error);
-          retryableFailure = true;
-          break;
+    const detector = options?.detectRepetition ? new RepetitionDetector() : null;
+    const streamAbort = new AbortController();
+    const onCallerAbort = () => streamAbort.abort();
+    if (params.signal) {
+      if (params.signal.aborted) {
+        streamAbort.abort();
+      } else {
+        params.signal.addEventListener("abort", onCallerAbort, { once: true });
+      }
+    }
+    try {
+      for await (const event of streamChat({
+        ...params,
+        signal: streamAbort.signal
+      })) {
+        if (event.type === "error") {
+          if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
+            options?.onRetry?.(attempt, event.error);
+            retryableFailure = true;
+            break;
+          }
+          yield event;
+          return;
         }
-        yield event;
-        return;
+        if (detector && (event.type === "text" || event.type === "thinking")) {
+          const loop = detector.feed(event.text);
+          if (loop) {
+            log2.warn("Repetition loop detected \u2014 aborting call", {
+              requestId: params.requestId,
+              kind: loop.kind,
+              repeats: loop.repeats
+            });
+            streamAbort.abort();
+            yield {
+              type: "error",
+              error: "Response stopped: the model was repeating its reasoning without making progress.",
+              code: "repetition_loop"
+            };
+            return;
+          }
+        }
+        buffer.push(event);
       }
-      buffer.push(event);
+    } finally {
+      params.signal?.removeEventListener("abort", onCallerAbort);
     }
     if (retryableFailure) {
       if (params.signal?.aborted) {
@@ -3031,6 +3146,13 @@ var queryDatabaseTool = {
 // src/usageLedger.ts
 import fs16 from "fs";
 var LEDGER_FILE = ".logs/usage.ndjson";
+function thinkingTokensFromBilling(billingEvents, outputTokens) {
+  if (!billingEvents?.length) {
+    return 0;
+  }
+  const billedResponseUnits = billingEvents.filter((e) => e.eventType.endsWith("-response")).reduce((sum, e) => sum + e.numUnits, 0);
+  return Math.max(0, billedResponseUnits - outputTokens);
+}
 var fd = null;
 function nanoToDollars(nano) {
   return typeof nano === "number" ? nano / 1e9 : void 0;
@@ -8961,6 +9083,13 @@ function getActionChain(startName) {
 }
 
 // src/errors.ts
+var OVERFLOW_PATTERN = /input token count.*exceeds|exceeds the maximum number of tokens|prompt is too long|context[_ ]length[_ ]exceeded|maximum context length|HTTP 413|payload too large|request entity too large/i;
+function isContextOverflowError(message, code) {
+  if (code === "context_overflow") {
+    return true;
+  }
+  return OVERFLOW_PATTERN.test(message);
+}
 var patterns = [
   [
     /Network error/i,
@@ -8980,6 +9109,14 @@ var patterns = [
     "The AI service is temporarily unavailable. Please try again."
   ],
   [/Stream stalled/i, "The connection was interrupted. Please try again."],
+  [
+    // A too-large-context failure that survived the automatic compact-and-retry
+    // (or came from an older server). Kept ahead of the generic fallback so a
+    // raw provider string (e.g. Gemini's INVALID_ARGUMENT JSON) never reaches
+    // the user.
+    OVERFLOW_PATTERN,
+    "This conversation outgrew the model's context window. Remy compacted it and tried again; if you keep seeing this, run /compact or start a new conversation."
+  ],
   [
     /content filter|Output blocked/i,
     "The AI model's content moderation filter blocked this response. These are usually false positives, we apologize for the interruption. Rephrasing your request typically fixes this."
@@ -9284,8 +9421,33 @@ async function runTurn(params) {
   let lastCallInputTokens = 0;
   let lastCallCacheCreation = 0;
   let lastCallCacheRead = 0;
-  let abnormalStopRecoveries = 0;
-  const MAX_ABNORMAL_STOP_RECOVERIES = 2;
+  let recoveries = 0;
+  const MAX_RECOVERIES = 2;
+  let midTurnCompactions = 0;
+  const MAX_MID_TURN_COMPACTIONS = 2;
+  let overflowRecovered = false;
+  const compactNow = async (reason) => {
+    log15.warn("Compacting mid-turn", {
+      requestId,
+      reason,
+      lastCallInputTokens
+    });
+    onEvent({ type: "status", message: "Compacting the conversation\u2026" });
+    try {
+      await triggerCompaction(state, apiConfig, {
+        blocking: true,
+        requestId,
+        model,
+        origin: "gate"
+      });
+      applyPendingSummaries(state);
+    } catch (err) {
+      log15.error("Mid-turn compaction failed", {
+        requestId,
+        error: err?.message ?? String(err)
+      });
+    }
+  };
   const statusWatcher = isFirstMessage ? { stop() {
   }, pause() {
   }, resume() {
@@ -9432,6 +9594,7 @@ async function runTurn(params) {
           onEvent({ type: "tool_input_delta", id, name, result: content });
         }
       }
+      let streamError = null;
       try {
         for await (const event of streamChatWithRetry(
           {
@@ -9450,9 +9613,13 @@ async function runTurn(params) {
             onRetry: (attempt) => {
               onEvent({
                 type: "status",
-                message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
+                message: `Lost connection, retrying (attempt ${attempt + 2} of ${MAX_RETRIES})`
               });
-            }
+            },
+            // Watch the streamed reasoning/text for a runaway repetition loop
+            // and abort the in-flight call early (RPT-1225). Surfaces as a
+            // `repetition_loop` error handled below.
+            detectRepetition: true
           }
         )) {
           if (signal?.aborted) {
@@ -9476,7 +9643,7 @@ async function runTurn(params) {
               emitTextBlockSnapshot2(false);
               break;
             }
-            case "thinking":
+            case "thinking": {
               if (event.text === "") {
                 thinkingBlockStartTimes.push(event.ts);
                 if (textBlockOpen) {
@@ -9486,6 +9653,7 @@ async function runTurn(params) {
               }
               onEvent({ type: "thinking", text: event.text });
               break;
+            }
             case "thinking_complete": {
               const startedAt = thinkingBlockStartTimes[thinkingCompleteCount] ?? event.ts;
               contentBlocks.push({
@@ -9583,6 +9751,10 @@ async function runTurn(params) {
                 outputTokens: event.usage.outputTokens,
                 cacheCreationTokens: event.usage.cacheCreationTokens,
                 cacheReadTokens: event.usage.cacheReadTokens,
+                thinkingTokens: thinkingTokensFromBilling(
+                  event.billingEvents,
+                  event.usage.outputTokens
+                ) || void 0,
                 cost: nanoToDollars(event.cost),
                 billingEvents: event.billingEvents,
                 durationMs: Date.now() - iterStart,
@@ -9592,13 +9764,11 @@ async function runTurn(params) {
               });
               break;
             case "error":
-              statusWatcher.stop();
-              onEvent({
-                type: "error",
-                error: friendlyError(event.error),
-                ...event.code ? { code: event.code } : {}
-              });
-              return;
+              streamError = { error: event.error, code: event.code };
+              break;
+          }
+          if (streamError) {
+            break;
           }
         }
       } catch (err) {
@@ -9643,6 +9813,51 @@ async function runTurn(params) {
         saveSession(state);
         return;
       }
+      if (streamError) {
+        const { error, code } = streamError;
+        if (code === "repetition_loop") {
+          if (recoveries < MAX_RECOVERIES && !signal?.aborted) {
+            recoveries++;
+            log15.warn("Repetition loop \u2014 nudging model to continue", {
+              requestId,
+              attempt: recoveries
+            });
+            const nudge = "Your previous response was stopped because it kept repeating the same reasoning without making progress. Do not deliberate further \u2014 take the next concrete action now: make the tool call or give the answer.";
+            state.messages.push({
+              role: "user",
+              content: nudge,
+              hidden: true
+            });
+            onEvent({ type: "user_message", text: nudge, hidden: true });
+            continue;
+          }
+          statusWatcher.stop();
+          saveSession(state);
+          log15.warn("Repetition loop over recovery cap \u2014 ending turn", {
+            requestId
+          });
+          onEvent({
+            type: "error",
+            error: "The model kept repeating itself without making progress, so Remy stopped the turn to avoid runaway cost. Try again, or rephrase your request.",
+            lastCallInputTokens
+          });
+          return;
+        }
+        if (isContextOverflowError(error, code) && !overflowRecovered && !signal?.aborted) {
+          overflowRecovered = true;
+          await compactNow("context overflow");
+          continue;
+        }
+        statusWatcher.stop();
+        saveSession(state);
+        onEvent({
+          type: "error",
+          error: friendlyError(error),
+          ...code ? { code } : {},
+          lastCallInputTokens
+        });
+        return;
+      }
       if (contentBlocks.length > 0) {
         state.messages.push({
           role: "assistant",
@@ -9662,14 +9877,14 @@ async function runTurn(params) {
         });
       }
       const toolCalls = getToolCalls(contentBlocks);
-      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && abnormalStopRecoveries < MAX_ABNORMAL_STOP_RECOVERIES && !signal?.aborted) {
-        abnormalStopRecoveries++;
+      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && recoveries < MAX_RECOVERIES && !signal?.aborted) {
+        recoveries++;
         log15.warn("Abnormal stop \u2014 nudging model to continue", {
           requestId,
           stopReason,
-          attempt: abnormalStopRecoveries
+          attempt: recoveries
         });
-        const nudge = "Your previous response was cut off \u2014 it degenerated into repeated text or hit the output limit, and the repeated portion was removed. Reassess where you are in the task and continue from where you left off. Prefer a tool call over restating what you were about to do.";
+        const nudge = "Your previous response was cut off before you finished \u2014 it hit the output limit (often from over-long reasoning) or degenerated into repeated text, and the unusable part was removed. Stop deliberating, reassess where you are, and continue with a concrete tool call rather than restating your plan.";
         state.messages.push({ role: "user", content: nudge, hidden: true });
         onEvent({ type: "user_message", text: nudge, hidden: true });
         continue;
@@ -9862,6 +10077,11 @@ async function runTurn(params) {
           isToolError: r.isError
         });
       }
+      const { forceCompactAt } = getContextLimits(parentModel);
+      if (lastCallInputTokens > forceCompactAt && midTurnCompactions < MAX_MID_TURN_COMPACTIONS && !signal?.aborted) {
+        midTurnCompactions++;
+        await compactNow(`context ${lastCallInputTokens} > ${forceCompactAt}`);
+      }
       if (takeSteering && !signal?.aborted) {
         const injected = (await takeSteering()).filter(
           (e) => e.text.trim().length > 0 || (e.attachments?.length ?? 0) > 0
@@ -10911,6 +11131,10 @@ var HeadlessSession = class {
         );
         return;
       case "error":
+        if (typeof e.lastCallInputTokens === "number") {
+          this.sessionStats.lastContextSize = e.lastCallInputTokens;
+          this.persistStats();
+        }
         this.emit(
           "error",
           { error: e.error, ...e.code ? { code: e.code } : {} },

package/dist/index.js

@@ -84,6 +84,93 @@ var init_logger = __esm({
   }
 });
 
+// src/loopGuard.ts
+function normalizeParagraph(seg) {
+  const trimmed = seg.trim();
+  if (!trimmed || LONE_HEADER.test(trimmed)) {
+    return null;
+  }
+  const key = trimmed.toLowerCase().replace(/\s+/g, " ");
+  if (key.length < MIN_PARAGRAPH_CHARS) {
+    return null;
+  }
+  return key;
+}
+var PARAGRAPH_REPEAT_THRESHOLD, MIN_PARAGRAPH_CHARS, CHUNK_SIZE, CHUNK_WINDOW, CHUNK_REPEAT_THRESHOLD, LONE_HEADER, RepetitionDetector;
+var init_loopGuard = __esm({
+  "src/loopGuard.ts"() {
+    "use strict";
+    PARAGRAPH_REPEAT_THRESHOLD = 6;
+    MIN_PARAGRAPH_CHARS = 80;
+    CHUNK_SIZE = 60;
+    CHUNK_WINDOW = 5e3;
+    CHUNK_REPEAT_THRESHOLD = 10;
+    LONE_HEADER = /^\*{1,3}[^*].*\*{1,3}$/;
+    RepetitionDetector = class {
+      // Paragraph detector: incomplete tail awaiting its closing blank line, plus
+      // occurrence counts of completed, normalized paragraphs.
+      paragraphBuffer = "";
+      paragraphCounts = /* @__PURE__ */ new Map();
+      // Rolling-chunk detector: the trailing window of raw fed text.
+      window = "";
+      fired = false;
+      /**
+       * Feed the next streamed text fragment. Returns a signal the first time a
+       * loop is recognized, then null forever after (the caller aborts on the
+       * first signal; further feeds are harmless no-ops).
+       */
+      feed(text) {
+        if (this.fired || !text) {
+          return null;
+        }
+        return this.feedParagraphs(text) ?? this.feedChunks(text);
+      }
+      feedParagraphs(text) {
+        this.paragraphBuffer += text;
+        const segments = this.paragraphBuffer.split(/\n\s*\n/);
+        this.paragraphBuffer = segments.pop() ?? "";
+        for (const seg of segments) {
+          const key = normalizeParagraph(seg);
+          if (!key) {
+            continue;
+          }
+          const count = (this.paragraphCounts.get(key) ?? 0) + 1;
+          this.paragraphCounts.set(key, count);
+          if (count >= PARAGRAPH_REPEAT_THRESHOLD) {
+            this.fired = true;
+            return {
+              kind: "paragraph",
+              repeats: count,
+              sample: seg.trim().slice(0, 160)
+            };
+          }
+        }
+        return null;
+      }
+      feedChunks(text) {
+        this.window = (this.window + text).slice(-CHUNK_WINDOW);
+        if (this.window.length < CHUNK_SIZE * CHUNK_REPEAT_THRESHOLD) {
+          return null;
+        }
+        const tail = this.window.slice(-CHUNK_SIZE);
+        if (!tail.trim()) {
+          return null;
+        }
+        const occurrences = this.window.split(tail).length - 1;
+        if (occurrences >= CHUNK_REPEAT_THRESHOLD) {
+          this.fired = true;
+          return {
+            kind: "chunk",
+            repeats: occurrences,
+            sample: tail.replace(/\s+/g, " ").trim().slice(0, 160)
+          };
+        }
+        return null;
+      }
+    };
+  }
+});
+
 // src/api.ts
 async function* streamChat(params) {
   const { baseUrl: baseUrl2, apiKey, signal, requestId, model, ...rest } = params;
@@ -286,17 +373,51 @@ async function* streamChatWithRetry(params, options) {
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const buffer = [];
     let retryableFailure = false;
-    for await (const event of streamChat(params)) {
-      if (event.type === "error") {
-        if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
-          options?.onRetry?.(attempt, event.error);
-          retryableFailure = true;
-          break;
+    const detector = options?.detectRepetition ? new RepetitionDetector() : null;
+    const streamAbort = new AbortController();
+    const onCallerAbort = () => streamAbort.abort();
+    if (params.signal) {
+      if (params.signal.aborted) {
+        streamAbort.abort();
+      } else {
+        params.signal.addEventListener("abort", onCallerAbort, { once: true });
+      }
+    }
+    try {
+      for await (const event of streamChat({
+        ...params,
+        signal: streamAbort.signal
+      })) {
+        if (event.type === "error") {
+          if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
+            options?.onRetry?.(attempt, event.error);
+            retryableFailure = true;
+            break;
+          }
+          yield event;
+          return;
         }
-        yield event;
-        return;
+        if (detector && (event.type === "text" || event.type === "thinking")) {
+          const loop = detector.feed(event.text);
+          if (loop) {
+            log.warn("Repetition loop detected \u2014 aborting call", {
+              requestId: params.requestId,
+              kind: loop.kind,
+              repeats: loop.repeats
+            });
+            streamAbort.abort();
+            yield {
+              type: "error",
+              error: "Response stopped: the model was repeating its reasoning without making progress.",
+              code: "repetition_loop"
+            };
+            return;
+          }
+        }
+        buffer.push(event);
       }
-      buffer.push(event);
+    } finally {
+      params.signal?.removeEventListener("abort", onCallerAbort);
     }
     if (retryableFailure) {
       if (params.signal?.aborted) {
@@ -375,6 +496,7 @@ var init_api = __esm({
   "src/api.ts"() {
     "use strict";
     init_logger();
+    init_loopGuard();
     log = createLogger("api");
     MAX_RETRIES = 5;
     INITIAL_BACKOFF_MS = 1e3;
@@ -1543,6 +1665,13 @@ var init_sentinel = __esm({
 
 // src/usageLedger.ts
 import fs9 from "fs";
+function thinkingTokensFromBilling(billingEvents, outputTokens) {
+  if (!billingEvents?.length) {
+    return 0;
+  }
+  const billedResponseUnits = billingEvents.filter((e) => e.eventType.endsWith("-response")).reduce((sum, e) => sum + e.numUnits, 0);
+  return Math.max(0, billedResponseUnits - outputTokens);
+}
 function nanoToDollars(nano) {
   return typeof nano === "number" ? nano / 1e9 : void 0;
 }
@@ -9311,6 +9440,12 @@ var init_resolve = __esm({
 });
 
 // src/errors.ts
+function isContextOverflowError(message, code) {
+  if (code === "context_overflow") {
+    return true;
+  }
+  return OVERFLOW_PATTERN.test(message);
+}
 function friendlyError(raw) {
   for (const [pattern, message] of patterns) {
     if (pattern.test(raw)) {
@@ -9319,10 +9454,11 @@ function friendlyError(raw) {
   }
   return `Something went wrong: ${raw}`;
 }
-var patterns;
+var OVERFLOW_PATTERN, patterns;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
+    OVERFLOW_PATTERN = /input token count.*exceeds|exceeds the maximum number of tokens|prompt is too long|context[_ ]length[_ ]exceeded|maximum context length|HTTP 413|payload too large|request entity too large/i;
     patterns = [
       [
         /Network error/i,
@@ -9342,6 +9478,14 @@ var init_errors = __esm({
         "The AI service is temporarily unavailable. Please try again."
       ],
       [/Stream stalled/i, "The connection was interrupted. Please try again."],
+      [
+        // A too-large-context failure that survived the automatic compact-and-retry
+        // (or came from an older server). Kept ahead of the generic fallback so a
+        // raw provider string (e.g. Gemini's INVALID_ARGUMENT JSON) never reaches
+        // the user.
+        OVERFLOW_PATTERN,
+        "This conversation outgrew the model's context window. Remy compacted it and tried again; if you keep seeing this, run /compact or start a new conversation."
+      ],
       [
         /content filter|Output blocked/i,
         "The AI model's content moderation filter blocked this response. These are usually false positives, we apologize for the interruption. Rephrasing your request typically fixes this."
@@ -9987,8 +10131,33 @@ async function runTurn(params) {
   let lastCallInputTokens = 0;
   let lastCallCacheCreation = 0;
   let lastCallCacheRead = 0;
-  let abnormalStopRecoveries = 0;
-  const MAX_ABNORMAL_STOP_RECOVERIES = 2;
+  let recoveries = 0;
+  const MAX_RECOVERIES = 2;
+  let midTurnCompactions = 0;
+  const MAX_MID_TURN_COMPACTIONS = 2;
+  let overflowRecovered = false;
+  const compactNow = async (reason) => {
+    log14.warn("Compacting mid-turn", {
+      requestId,
+      reason,
+      lastCallInputTokens
+    });
+    onEvent({ type: "status", message: "Compacting the conversation\u2026" });
+    try {
+      await triggerCompaction(state, apiConfig, {
+        blocking: true,
+        requestId,
+        model,
+        origin: "gate"
+      });
+      applyPendingSummaries(state);
+    } catch (err) {
+      log14.error("Mid-turn compaction failed", {
+        requestId,
+        error: err?.message ?? String(err)
+      });
+    }
+  };
   const statusWatcher = isFirstMessage ? { stop() {
   }, pause() {
   }, resume() {
@@ -10135,6 +10304,7 @@ async function runTurn(params) {
           onEvent({ type: "tool_input_delta", id, name, result: content });
         }
       }
+      let streamError = null;
       try {
         for await (const event of streamChatWithRetry(
           {
@@ -10153,9 +10323,13 @@ async function runTurn(params) {
             onRetry: (attempt) => {
               onEvent({
                 type: "status",
-                message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
+                message: `Lost connection, retrying (attempt ${attempt + 2} of ${MAX_RETRIES})`
               });
-            }
+            },
+            // Watch the streamed reasoning/text for a runaway repetition loop
+            // and abort the in-flight call early (RPT-1225). Surfaces as a
+            // `repetition_loop` error handled below.
+            detectRepetition: true
           }
         )) {
           if (signal?.aborted) {
@@ -10179,7 +10353,7 @@ async function runTurn(params) {
               emitTextBlockSnapshot2(false);
               break;
             }
-            case "thinking":
+            case "thinking": {
               if (event.text === "") {
                 thinkingBlockStartTimes.push(event.ts);
                 if (textBlockOpen) {
@@ -10189,6 +10363,7 @@ async function runTurn(params) {
               }
               onEvent({ type: "thinking", text: event.text });
               break;
+            }
             case "thinking_complete": {
               const startedAt = thinkingBlockStartTimes[thinkingCompleteCount] ?? event.ts;
               contentBlocks.push({
@@ -10286,6 +10461,10 @@ async function runTurn(params) {
                 outputTokens: event.usage.outputTokens,
                 cacheCreationTokens: event.usage.cacheCreationTokens,
                 cacheReadTokens: event.usage.cacheReadTokens,
+                thinkingTokens: thinkingTokensFromBilling(
+                  event.billingEvents,
+                  event.usage.outputTokens
+                ) || void 0,
                 cost: nanoToDollars(event.cost),
                 billingEvents: event.billingEvents,
                 durationMs: Date.now() - iterStart,
@@ -10295,13 +10474,11 @@ async function runTurn(params) {
               });
               break;
             case "error":
-              statusWatcher.stop();
-              onEvent({
-                type: "error",
-                error: friendlyError(event.error),
-                ...event.code ? { code: event.code } : {}
-              });
-              return;
+              streamError = { error: event.error, code: event.code };
+              break;
+          }
+          if (streamError) {
+            break;
           }
         }
       } catch (err) {
@@ -10346,6 +10523,51 @@ async function runTurn(params) {
         saveSession(state);
         return;
       }
+      if (streamError) {
+        const { error, code } = streamError;
+        if (code === "repetition_loop") {
+          if (recoveries < MAX_RECOVERIES && !signal?.aborted) {
+            recoveries++;
+            log14.warn("Repetition loop \u2014 nudging model to continue", {
+              requestId,
+              attempt: recoveries
+            });
+            const nudge = "Your previous response was stopped because it kept repeating the same reasoning without making progress. Do not deliberate further \u2014 take the next concrete action now: make the tool call or give the answer.";
+            state.messages.push({
+              role: "user",
+              content: nudge,
+              hidden: true
+            });
+            onEvent({ type: "user_message", text: nudge, hidden: true });
+            continue;
+          }
+          statusWatcher.stop();
+          saveSession(state);
+          log14.warn("Repetition loop over recovery cap \u2014 ending turn", {
+            requestId
+          });
+          onEvent({
+            type: "error",
+            error: "The model kept repeating itself without making progress, so Remy stopped the turn to avoid runaway cost. Try again, or rephrase your request.",
+            lastCallInputTokens
+          });
+          return;
+        }
+        if (isContextOverflowError(error, code) && !overflowRecovered && !signal?.aborted) {
+          overflowRecovered = true;
+          await compactNow("context overflow");
+          continue;
+        }
+        statusWatcher.stop();
+        saveSession(state);
+        onEvent({
+          type: "error",
+          error: friendlyError(error),
+          ...code ? { code } : {},
+          lastCallInputTokens
+        });
+        return;
+      }
       if (contentBlocks.length > 0) {
         state.messages.push({
           role: "assistant",
@@ -10365,14 +10587,14 @@ async function runTurn(params) {
         });
       }
       const toolCalls = getToolCalls(contentBlocks);
-      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && abnormalStopRecoveries < MAX_ABNORMAL_STOP_RECOVERIES && !signal?.aborted) {
-        abnormalStopRecoveries++;
+      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && recoveries < MAX_RECOVERIES && !signal?.aborted) {
+        recoveries++;
         log14.warn("Abnormal stop \u2014 nudging model to continue", {
           requestId,
           stopReason,
-          attempt: abnormalStopRecoveries
+          attempt: recoveries
         });
-        const nudge = "Your previous response was cut off \u2014 it degenerated into repeated text or hit the output limit, and the repeated portion was removed. Reassess where you are in the task and continue from where you left off. Prefer a tool call over restating what you were about to do.";
+        const nudge = "Your previous response was cut off before you finished \u2014 it hit the output limit (often from over-long reasoning) or degenerated into repeated text, and the unusable part was removed. Stop deliberating, reassess where you are, and continue with a concrete tool call rather than restating your plan.";
         state.messages.push({ role: "user", content: nudge, hidden: true });
         onEvent({ type: "user_message", text: nudge, hidden: true });
         continue;
@@ -10565,6 +10787,11 @@ async function runTurn(params) {
           isToolError: r.isError
         });
       }
+      const { forceCompactAt } = getContextLimits(parentModel);
+      if (lastCallInputTokens > forceCompactAt && midTurnCompactions < MAX_MID_TURN_COMPACTIONS && !signal?.aborted) {
+        midTurnCompactions++;
+        await compactNow(`context ${lastCallInputTokens} > ${forceCompactAt}`);
+      }
       if (takeSteering && !signal?.aborted) {
         const injected = (await takeSteering()).filter(
           (e) => e.text.trim().length > 0 || (e.attachments?.length ?? 0) > 0
@@ -10606,6 +10833,7 @@ var init_agent = __esm({
     init_sentinel();
     init_trigger2();
     init_surfaces();
+    init_trigger();
     init_toolRegistry();
     init_historyLimits();
     log14 = createLogger("agent");
@@ -11958,6 +12186,10 @@ var init_headless = __esm({
             );
             return;
           case "error":
+            if (typeof e.lastCallInputTokens === "number") {
+              this.sessionStats.lastContextSize = e.lastCallInputTokens;
+              this.persistStats();
+            }
             this.emit(
               "error",
               { error: e.error, ...e.code ? { code: e.code } : {} },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/remy",
-  "version": "0.1.329",
+  "version": "0.1.330",
   "description": "Remy coding agent",
   "repository": {
     "type": "git",