jaitus 0.3.10 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.10",
+  "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/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();