jaitus 0.3.9 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {

package/src/agent/loop.js

@@ -353,6 +353,13 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
     }
   };
   let buffer = '';
+  // A stream that never ends must die here, not in GC hell: the buffer below grows
+  // with every chunk and each arrival re-splits all of it, so a runaway provider
+  // (twelve silent minutes and counting, seen in the wild) grows memory
+  // quadratically until V8 falls over near 4 GB. Past the cap the turn ends as a
+  // cut (continued from what arrived) or, with nothing received, as a retryable
+  // timeout — never as a crash.
+  const MAX_STREAM_BUFFER = 8 * 1024 * 1024;
   // A failure reported INSIDE the stream, after a 200. Recorded here and thrown after
   // the parse below: handle() runs inside a try whose catch exists to skip keepalives,
   // so throwing from it would be swallowed — which is how a mid-stream error used to
@@ -412,6 +419,13 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
   try {
     for await (const chunk of res.body) {
       buffer += decoder.decode(chunk, { stream: true });
+      if (buffer.length > MAX_STREAM_BUFFER) {
+        // Breaking the loop releases the reader (the socket is cancelled), so the
+        // runaway stops arriving too — not just stops being kept.
+        if (!blocks.size) throw new JaitusError({ code: 'timeout', status: 504, message: 'Jaitus took too long to respond. Try again.' });
+        cut = true;
+        break;
+      }
       const frames = buffer.split('\n\n');
       buffer = frames.pop() || '';
       for (const frame of frames) {

package/src/index.js

@@ -1181,7 +1181,8 @@ async function session({ flags }) {
       ledger.note('compacted', `The conversation was automatically summarised to free context: ${dropped} messages became one summary. Detail you are not shown above is genuinely gone — ask or re-read rather than assuming.`);
     } catch (error) {
       // Not fatal: the turn can still run, it just runs closer to the ceiling.
-      tui.notice?.(`Auto-compaction failed (${error.message}) — continuing without it. /compact retries.`, 'warn');
+      const id = isJaitusError(error) && error.requestId ? ` (request id ${error.requestId})` : '';
+      tui.notice?.(`Auto-compaction failed (${error.message}${id}) — continuing without it. /compact retries.`, 'warn');
       ledger.note('compact-failed', `Automatic context compaction failed (${error.message}); the conversation is close to the context limit.`);
     } finally {
       tui.clearStatus?.();
@@ -1830,7 +1831,11 @@ async function slashCommand(verb, args, ctx) {
         ok('Conversation compacted. Context freed.');
         try { ctx.resetContext?.(); } catch { /* header keeps last value */ }
       } catch (e) {
-        fail(`Compact failed: ${e.message}`);
+        // The request id is the only thing that ties this failure to a backend log
+        // line. fail() takes a string, so a JaitusError passed bare would shed it —
+        // and "where do I get the request id" is exactly what that produces.
+        const id = isJaitusError(e) && e.requestId ? ` (request id ${e.requestId})` : '';
+        fail(`Compact failed: ${e.message}${id}`);
       } finally {
         spin.stop();
       }

package/src/rewind.js

@@ -29,11 +29,29 @@ export function createJournal() {
   return {
     /** Snapshot the conversation before a user prompt is processed. */
     checkpoint(messages, files = []) {
+      // Checkpoints are full deep clones with NO size cap (only file snapshots are
+      // capped above) — with pasted images in history, 60 checkpoints of megabytes
+      // of base64 each is a straight road to heap death. Past the cap the CHECKPOINT
+      // copy keeps its structure but drops the pixels (live messages are untouched):
+      // rewinding across an image restores a note, not the pixels. Undo stays usable
+      // instead of OOMing the session.
+      const MAX_CHECKPOINT_BYTES = 4_000_000;
+      let snap;
+      try {
+        const raw = JSON.stringify(messages);
+        snap = raw.length > MAX_CHECKPOINT_BYTES
+          ? JSON.parse(JSON.stringify(messages, (key, value) =>
+              (key === 'data' && typeof value === 'string' && value.length > 100_000
+                ? '[image data omitted from checkpoint]' : value)))
+          : JSON.parse(raw);
+      } catch {
+        snap = [];
+      }
       checkpoints.push({
         seq: ++seqCounter,
         at: new Date().toISOString(),
         prompt: messages.filter((m) => m.role === 'user' && typeof m.content === 'string').at(-1)?.content?.slice(0, 120) || '',
-        messages: JSON.parse(JSON.stringify(messages)),
+        messages: snap,
         files,
       });
       if (checkpoints.length > 60) checkpoints.shift();