@inceptionstack/roundhouse 0.5.25 → 0.5.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.25",
+  "version": "0.5.26",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/src/gateway/gateway.ts

@@ -439,6 +439,26 @@ export class Gateway {
 
       stopTyping = startTypingLoop(thread);
 
+      // Pre-turn recovery: if a prior turn failed to compact (state has
+      // pendingCompact === "emergency"), the live session is almost certainly
+      // still over the model's context limit, so calling agent.prompt() now
+      // will throw with "prompt is too long" before our post-turn pressure
+      // handler ever runs — perpetuating the loop. Run the pressure handler
+      // BEFORE the agent call to recover. Best-effort: if it fails, fall
+      // through to the normal turn (which will then post the error and let
+      // the user see something is wrong).
+      if (memoryPrepared?.pendingCompact === "emergency") {
+        console.log(`[roundhouse] pre-turn recovery: pendingCompact=emergency, compacting before agent.prompt for thread=${agentThreadId}`);
+        try {
+          await this.handleContextPressure(thread, agentThreadId, agent, memoryRoot, "emergency");
+          // Clear the pending flag in our prepared snapshot so the post-turn
+          // pressure logic doesn't double-up on a redundant emergency pass.
+          memoryPrepared.pendingCompact = undefined;
+        } catch (err) {
+          console.error(`[roundhouse] pre-turn emergency compact failed:`, (err as Error).message);
+        }
+      }
+
       let deferredSoftFlush: { thread: any; agentThreadId: string; agent: AgentAdapter; memoryRoot: string } | undefined;
       try {
         let turnUsedTools = false;

package/src/memory/lifecycle.ts

@@ -239,7 +239,15 @@ export async function flushMemoryThenCompact(
   // NOT require the live session to fit under the limit — so skipping flush
   // lets us recover. Facts-to-MEMORY.md (the whole point of flush) is a
   // best-effort nicety that the next soft/hard flush can catch up on.
-  const skipFlush = effectiveLevel === "emergency";
+  //
+  // We also skip flush when state already has pendingCompact === "emergency":
+  // a prior turn detected emergency pressure and could not complete (e.g. the
+  // current call was triggered by /compact while stuck). Even at "hard" or
+  // "manual" level, attempting the flush in that condition will hit the same
+  // 200k rejection. Deferring flush to a later (successful) turn is the safe
+  // recovery path.
+  const stuckInEmergency = (await loadThreadMemoryState(threadId)).pendingCompact === "emergency";
+  const skipFlush = effectiveLevel === "emergency" || stuckInEmergency;
 
   try {
     let flushMs = 0;
@@ -255,10 +263,12 @@ export async function flushMemoryThenCompact(
     }
 
     // Step 2: compact (use flush model if compactWithModel is available)
-    const flushNote = skipFlush ? "flush skipped (emergency)" : `flush took ${flushMs}ms`;
+    const flushNote = skipFlush
+      ? (effectiveLevel === "emergency" ? "flush skipped (emergency)" : "flush skipped (recovery from prior emergency)")
+      : `flush took ${flushMs}ms`;
     console.log(`[memory] compacting ${threadId} (${flushNote})`);
     const progressNote = skipFlush
-      ? "✂️ Compacting context... (emergency — skipping flush)"
+      ? `✂️ Compacting context... (${effectiveLevel === "emergency" ? "emergency — " : "recovery — "}skipping flush)`
       : `✂️ Compacting context... (flush took ${(flushMs / 1000).toFixed(1)}s)`;
     await onProgress?.(progressNote);
     const t1 = Date.now();