jaitus 0.3.14 → 0.3.17

package/src/compact.js

@@ -0,0 +1,224 @@
+// ─── Compaction: summarising a conversation so it fits again ──────────────────────
+//
+// Shared by /compact, automatic compaction between prompts, compaction between the
+// steps of one long task, and the automatic recovery from "too large / too long".
+//
+// The one rule: the summary request itself must always fit. It used to carry up to
+// 360,000 characters of transcript whatever the model's window was, with pasted text and
+// @mentions unclipped — so on exactly the sessions that needed it, /compact failed with
+// the same "too long" error it was meant to cure, and the history stayed as it was.
+// Now the transcript is sized from the window the gateway advertises, a session bigger
+// than that is summarised in parts (each part folded into the summary so far), and a
+// refused summary request is retried with half as much.
+
+import { streamTurn } from './agent/loop.js';
+import { JaitusError } from './errors.js';
+
+/** Errors that mean "this request is too big" — the ones compaction can cure. */
+export const SIZE_FAULTS = new Set(['context_too_long', 'request_too_large']);
+
+/** Rough token estimate — ~4 characters per token of English. */
+export function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages || []) {
+    if (typeof m.content === 'string') chars += m.content.length;
+    else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === 'text') chars += (b.text || '').length;
+        else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length;
+        else if (b.type === 'tool_result') {
+          chars += typeof b.content === 'string' ? b.content.length
+            : Array.isArray(b.content) ? b.content.reduce((n, c) => n + (c?.text?.length || (c?.type === 'image' ? 6000 : 0)), 0) : 0;
+        } else if (b.type === 'image') chars += 6000; // ~1.5k tokens, what providers count for one
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+/** How many characters of transcript one summary request may carry for this window. */
+export function summaryBudgetChars(contextTokens) {
+  const window = Number(contextTokens) > 0 ? Number(contextTokens) : 128_000;
+  // Half the window for the transcript (≈ 2 characters per token of window, code and
+  // JSON tokenise denser than prose), the rest for the instructions, the reply and the
+  // gateway's own system prompt. Bounded: a 1M window does not need a 2 MB request.
+  return Math.max(20_000, Math.min(240_000, Math.floor(window * 2)));
+}
+
+const clip = (s, n) => (s.length > n ? `${s.slice(0, n)}… [${s.length - n} more characters left out]` : s);
+
+/**
+ * The conversation as plain lines, for summarising. Tool calls and results become short
+ * lines, images a note, and any one text block is clipped — the person's own words are
+ * kept far longer than anything a tool printed, because they are what a summary must
+ * not lose.
+ */
+export function transcriptLines(messages) {
+  const lines = [];
+  for (const m of messages || []) {
+    const who = m.role === 'assistant' ? 'ASSISTANT' : 'USER';
+    const textCap = m.role === 'assistant' ? 6_000 : 12_000;
+    if (typeof m.content === 'string') { lines.push(`${who}: ${clip(m.content, textCap)}`); continue; }
+    for (const b of Array.isArray(m.content) ? m.content : []) {
+      if (b?.type === 'text' && b.text) lines.push(`${who}: ${clip(b.text, textCap)}`);
+      else if (b?.type === 'tool_use') lines.push(`${who} ran ${b.name}: ${clip(JSON.stringify(b.input ?? {}), 400)}`);
+      else if (b?.type === 'tool_result') {
+        const t = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.map((c) => c?.text || '').join('\n') : '';
+        lines.push(`RESULT${b.is_error ? ' (error)' : ''}: ${clip(t, 1500)}`);
+      } else if (b?.type === 'image') lines.push(`${who}: [an image]`);
+    }
+  }
+  return lines;
+}
+
+/** Lines → parts of at most `maxChars` each, cutting only between lines. */
+export function chunkLines(lines, maxChars) {
+  const parts = [];
+  let cur = '';
+  for (const line of lines) {
+    const l = line.length > maxChars ? clip(line, maxChars - 80) : line;
+    if (cur && cur.length + l.length + 1 > maxChars) { parts.push(cur); cur = ''; }
+    cur = cur ? `${cur}\n${l}` : l;
+  }
+  if (cur) parts.push(cur);
+  return parts;
+}
+
+/** Kept for callers that want the single-request transcript (and its tests). */
+export function transcriptForSummary(messages, maxChars = 240_000) {
+  let text = transcriptLines(messages).join('\n');
+  if (text.length > maxChars) {
+    const head = text.slice(0, Math.floor(maxChars * 0.25));
+    const tail = text.slice(-Math.floor(maxChars * 0.7));
+    text = `${head}\n\n[… the middle of the session is left out …]\n\n${tail}`;
+  }
+  return text;
+}
+
+const HEADINGS = 'Use these headings, and be specific (paths, names, numbers) rather than general:\n'
+  + '1. Request — what the user asked for, with their exact words for any instruction, constraint or preference.\n'
+  + '2. Corrections — anything the user rejected, corrected or asked to do differently, verbatim where short.\n'
+  + '3. Files — every file read or changed: path, what changed or what matters in it.\n'
+  + '4. Commands and results — what was run and what it showed (test/build results, errors and how each was fixed).\n'
+  + '5. Decisions — what was chosen and why.\n'
+  + '6. Current state — exactly what was being done when this summary was made, and what is unfinished.\n'
+  + '7. Next step — the single next action, if the work was mid-way.\n'
+  + 'Omit headings that have nothing. No preamble.';
+
+async function summaryRequest(client, model, prompt, signal) {
+  // Streamed, like every other turn: the proxy in front of the gateway cuts a response
+  // that is silent for 100 s, and a long summary used to be exactly that.
+  const turn = await streamTurn({
+    client,
+    model,
+    // Room for the model to reason before it writes; at 2048 the reasoning could use
+    // it all and the summary came back empty.
+    maxTokens: 6000,
+    system: 'You write precise working summaries of coding sessions.',
+    messages: [{ role: 'user', content: prompt }],
+    signal,
+  });
+  // Half a summary would silently become the whole memory of the session.
+  if (turn.stopReason === 'cut') throw new JaitusError({ code: 'interrupted', message: 'The summary was cut off on the way. Try /compact again.' });
+  const text = (turn.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim();
+  if (!text) throw new Error('the summary came back empty');
+  return text;
+}
+
+/**
+ * Summarise `messages`. `contextTokens` is the window the gateway advertises; the
+ * transcript is cut into parts that fit it, and each part is folded into the summary so
+ * far (a rolling summary — nothing in the middle is dropped). A part the provider still
+ * refuses as too large is retried at half the size, down to a floor.
+ */
+export async function summarise(client, model, messages, focus = '', { contextTokens = 128_000, signal, onProgress } = {}) {
+  const lines = transcriptLines(messages);
+  let budget = summaryBudgetChars(contextTokens);
+  const focusNote = focus ? ` Focus on: ${focus}.` : '';
+  for (let attempt = 0; ; attempt++) {
+    const parts = chunkLines(lines, budget);
+    try {
+      let summary = '';
+      for (let i = 0; i < parts.length; i++) {
+        if (parts.length > 1) onProgress?.(i + 1, parts.length);
+        const prompt = summary
+          ? `You are summarising a long coding session in parts. Here is the summary of everything before this part:\n<summary>\n${summary}\n</summary>\n\n`
+            + `Write ONE updated summary that keeps everything that still matters from it and adds this part. ${HEADINGS}${focusNote}`
+            + `\n\n<conversation part="${i + 1} of ${parts.length}">\n${parts[i]}\n</conversation>`
+          : 'Summarize this conversation for a successor agent that will continue the work with no other memory of it. '
+            + `${HEADINGS}${focusNote}\n\n<conversation>\n${parts[i]}\n</conversation>`;
+        summary = await summaryRequest(client, model, prompt, signal);
+      }
+      return summary;
+    } catch (e) {
+      if (!SIZE_FAULTS.has(e?.code) || budget <= 20_000 || attempt >= 3) throw e;
+      budget = Math.max(20_000, Math.floor(budget / 2));
+    }
+  }
+}
+
+/** The single message a summary becomes. */
+export const summaryMessage = (summary) => ({ role: 'user', content: `[Earlier conversation, summarized:]\n${summary}\n\n[Continue from here.]` });
+
+/**
+ * Where to cut so the newest exchange stays word for word. Between the steps of a task
+ * the history ends with the model's tool calls and their results: those stay, so the
+ * task carries on from them. Before a new prompt the last message is the person's: it
+ * stays, so their question is sent whole instead of as a summary of it.
+ */
+export function tailStart(messages) {
+  const n = messages.length;
+  if (n < 2) return n;
+  const last = messages[n - 1];
+  const prev = messages[n - 2];
+  const hasResults = Array.isArray(last?.content) && last.content.some((b) => b?.type === 'tool_result');
+  if (last?.role === 'user' && hasResults && prev?.role === 'assistant') return n - 2;
+  if (last?.role === 'user') return n - 1;
+  return n;
+}
+
+/**
+ * Replace `messages` (in place) with a summary of everything before the tail, followed
+ * by the tail. Returns what happened, or null when there was too little to compact.
+ */
+export async function compactInPlace(client, model, messages, { focus = '', contextTokens, keepTail = true, signal, onProgress } = {}) {
+  const cut = keepTail ? tailStart(messages) : messages.length;
+  const head = messages.slice(0, cut);
+  if (!head.length) return null;
+  const tail = messages.slice(cut);
+  const before = estimateTokens(messages);
+  const summary = await summarise(client, model, head, focus, { contextTokens, signal, onProgress });
+  messages.length = 0;
+  // The tail after a summary must still alternate: summary (user) → assistant tool calls
+  // → user results. A tail that starts with the person's message is joined to the
+  // summary instead, so two user messages never sit side by side.
+  if (tail[0]?.role === 'user') {
+    const t = tail[0];
+    const blocks = typeof t.content === 'string' ? [{ type: 'text', text: t.content }] : t.content;
+    messages.push({ role: 'user', content: [{ type: 'text', text: summaryMessage(summary).content }, ...blocks] }, ...tail.slice(1));
+  } else {
+    messages.push(summaryMessage(summary), ...tail);
+  }
+  return { before, after: estimateTokens(messages), dropped: head.length };
+}
+
+/**
+ * Images are the usual reason a request is too large in BYTES. Every image except those
+ * in the newest message becomes a short note.
+ */
+export function dropOldImages(messages) {
+  let dropped = 0;
+  for (let i = 0; i < messages.length - 1; i++) {
+    const m = messages[i];
+    if (!Array.isArray(m.content)) continue;
+    m.content = m.content.map((b) => {
+      if (b?.type === 'image') { dropped++; return { type: 'text', text: '[an image was here; removed to keep the request small]' }; }
+      if (b?.type === 'tool_result' && Array.isArray(b.content) && b.content.some((c) => c?.type === 'image')) {
+        dropped++;
+        return { ...b, content: b.content.map((c) => (c?.type === 'image' ? { type: 'text', text: '[an image was here; removed to keep the request small]' } : c)) };
+      }
+      return b;
+    });
+  }
+  return dropped;
+}

package/src/errors.js

@@ -13,6 +13,8 @@ const CATALOG = {
   account_suspended: { title: 'Account suspended', hint: 'Contact support if you think this is a mistake.' },
   email_unverified: { title: 'Email not verified', hint: 'Open the verification link in your inbox, then retry.' },
   free_limit_reached: { title: 'Free prompts used up', hint: 'Subscribe on the website, then retry this turn.' },
+  free_machine_limit: { title: 'No free prompts on this account', hint: 'Subscribe on the website to keep using Jaitus on this account.' },
+  free_needs_cli: { title: 'Update Jaitus for free prompts', hint: 'Run npm i -g jaitus, then try again.' },
   free_request_too_large: { title: 'Too large for the free plan', hint: 'Run /compact or start a new session, or subscribe.' },
   plan_limit_reached: { title: 'Monthly allowance used', hint: 'It resets at the start of your next period, or upgrade on the website. /usage shows where you are.' },
   rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },