clixad 0.0.1-beta.48 → 0.0.1-beta.49

package/dist/{chunk-CNLFGTYS.mjs → chunk-E7SAKAVQ.mjs}

@@ -468,6 +468,13 @@ var MaintenanceError = class extends Error {
   }
 };
 var MAINTENANCE = "maintenance";
+var PromptTooLongError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PromptTooLongError";
+  }
+};
+var PROMPT_TOO_LONG = "prompt_too_long";
 async function refusal503(res, what) {
   const text = await res.text().catch(() => "");
   try {
@@ -537,7 +544,7 @@ async function refusal400(res, what) {
   const text = await res.text().catch(() => "");
   try {
     const body = JSON.parse(text);
-    if (body.error === "prompt_too_long" && typeof body.message === "string") return new Error(body.message);
+    if (body.error === PROMPT_TOO_LONG && typeof body.message === "string") return new PromptTooLongError(body.message);
   } catch {
   }
   const detail = safeDetail(text);
@@ -1482,6 +1489,7 @@ var GatewayClient = class {
     }
     if (premiumRefusal) throw premiumRefusal;
     if (streamError && streamErrorType === MAINTENANCE) throw new MaintenanceError(streamError);
+    if (streamError && streamErrorType === PROMPT_TOO_LONG) throw new PromptTooLongError(streamError);
     if (streamError && streamErrorType && LIMIT_REFUSALS.has(streamErrorType)) {
       throw new LimitRefusalError(streamError, streamErrorType, spendable ? { figures: spendable, balance } : void 0);
     }
@@ -6830,6 +6838,24 @@ var COMPACT_THRESHOLD = 0.75;
 function shouldCompact(messages, contextTokens, threshold = COMPACT_THRESHOLD) {
   return conversationTokens(messages) > contextTokens * threshold;
 }
+function compactBudget(contextTokens) {
+  return Math.floor(contextTokens * COMPACT_THRESHOLD);
+}
+function messageWeight(message) {
+  let images = 0;
+  const content = Array.isArray(message.content) ? message.content.map((part) => {
+    if (part.type !== "image_url") return part;
+    images++;
+    return { ...part, image_url: { url: "" } };
+  }) : message.content;
+  const bytes = Buffer.byteLength(JSON.stringify({ ...message, content }));
+  return Math.ceil(bytes / 4) + images * IMAGE_TOKEN_ESTIMATE;
+}
+function requestTokens(messages) {
+  let total = 0;
+  for (const m of messages) total += messageWeight(m);
+  return total;
+}
 function cutPoint(messages, keepTurns = 2) {
   let seen = 0;
   for (let i = messages.length - 1; i > 0; i--) {
@@ -6839,37 +6865,187 @@ function cutPoint(messages, keepTurns = 2) {
   }
   return 0;
 }
+function safeCuts(messages) {
+  const open = /* @__PURE__ */ new Set();
+  const cuts = [];
+  for (let i = 1; i <= messages.length; i++) {
+    const prev = messages[i - 1];
+    if (prev.role === "assistant") for (const call of prev.tool_calls ?? []) open.add(call.id);
+    if (prev.role === "tool" && prev.tool_call_id) open.delete(prev.tool_call_id);
+    if (open.size === 0 && (i === messages.length || messages[i].role !== "tool")) cuts.push(i);
+  }
+  return cuts;
+}
 var SUMMARY_LEAD = "Summary of the earlier conversation:\n\n";
 var SUMMARY_ACK = "Understood \u2014 continuing from that summary.";
-var SUMMARY_PROMPT = "Summarise the conversation above for your future self, which will continue the work without seeing it. Cover: what the user asked for, what was already changed (files and the reasoning), what was learned about the codebase, and what is still open. Be specific about file paths and names. No preamble.";
-async function compact(client, model, messages, opts = {}) {
-  const cut2 = cutPoint(messages, opts.keepTurns ?? 2);
-  if (cut2 <= 1) return void 0;
+function withSummary(summary, rest) {
+  const lead = { role: "user", content: `${SUMMARY_LEAD}${summary}` };
+  return rest[0]?.role === "assistant" ? [lead, ...rest] : [lead, { role: "assistant", content: SUMMARY_ACK }, ...rest];
+}
+function summaryReserve(budget) {
+  return Math.min(1e4, Math.max(1e3, Math.floor(budget / 6)));
+}
+function summaryPrompt(words) {
+  return `Summarise the conversation above for your future self, which will continue the work without seeing it. Cover: what the user asked for, what was already changed (files and the reasoning), what was learned about the codebase, and what is still open. Be specific about file paths and names. If it opens with a summary of earlier messages, carry what that summary says forward. At most ${words.toLocaleString("en-US")} words. No preamble.`;
+}
+function planCompaction(messages, contextTokens, keepTurns = 2) {
+  if (messages.length < 2) return void 0;
+  const budget = compactBudget(contextTokens);
+  const suffix = new Array(messages.length + 1).fill(0);
+  for (let i = messages.length - 1; i >= 0; i--) suffix[i] = suffix[i + 1] + messageWeight(messages[i]);
+  const total = suffix[0];
+  const tail = (from) => suffix[from];
+  const fixed = total - suffix[1] + summaryReserve(budget) + messageWeight({ role: "assistant", content: SUMMARY_ACK });
+  const preferred = cutPoint(messages, keepTurns);
+  const over = total > budget;
+  if (!over) return preferred > 1 ? { cut: preferred, fits: fixed + tail(preferred) <= budget, over } : void 0;
+  const cuts = safeCuts(messages).filter((c) => c >= Math.max(preferred, 2));
+  if (cuts.length === 0) return void 0;
+  const keep = Math.min(budget - fixed, Math.floor(budget / 2));
+  const cut2 = cuts.find((c) => tail(c) <= keep) ?? cuts.at(-1);
+  return { cut: cut2, fits: fixed + tail(cut2) <= budget, over };
+}
+function cutNote(left) {
+  return `
+\u2026 [${left.toLocaleString("en-US")} more characters left out here]`;
+}
+function capText(text, limit) {
+  return text.length > limit ? `${text.slice(0, limit)}${cutNote(text.length - limit)}` : text;
+}
+function capArguments(json, limit) {
+  const walk2 = (v) => {
+    if (typeof v === "string") return capText(v, limit);
+    if (Array.isArray(v)) return v.map(walk2);
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, walk2(x)]));
+    return v;
+  };
+  try {
+    return JSON.stringify(walk2(JSON.parse(json)));
+  } catch {
+    return json.length > limit ? JSON.stringify({ arguments: capText(json, limit) }) : json;
+  }
+}
+function capMessage(message, limit) {
+  const content = typeof message.content === "string" ? capText(message.content, limit) : Array.isArray(message.content) ? message.content.map((part) => part.type === "text" ? { ...part, text: capText(part.text, limit) } : part) : message.content;
+  const out = { ...message, content };
+  if (message.tool_calls) {
+    out.tool_calls = message.tool_calls.map((c) => ({
+      ...c,
+      function: { ...c.function, arguments: capArguments(c.function.arguments, limit) }
+    }));
+  }
+  return out;
+}
+function withoutImages2(message) {
+  if (!Array.isArray(message.content)) return message;
+  return {
+    ...message,
+    content: message.content.map(
+      (part) => part.type === "image_url" ? { type: "text", text: "[an image, not shown here]" } : part
+    )
+  };
+}
+function longestText(messages) {
+  let longest = 0;
+  for (const m of messages) {
+    longest = Math.max(longest, messageText(m).length);
+    for (const c of m.tool_calls ?? []) longest = Math.max(longest, c.function.arguments.length);
+  }
+  return longest;
+}
+function shrinkToFit(messages, room) {
+  if (requestTokens(messages) <= room) return messages;
+  const plain2 = messages.map(withoutImages2);
+  if (requestTokens(plain2) <= room) return plain2;
+  const capped = (limit) => plain2.map((m) => capMessage(m, limit));
+  let lo = 0;
+  let hi = longestText(plain2);
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (requestTokens(capped(mid)) <= room) lo = mid;
+    else hi = mid - 1;
+  }
+  return capped(lo);
+}
+async function compact(client, model, messages, contextTokens, opts = {}) {
+  const plan = planCompaction(messages, contextTokens, opts.keepTurns ?? 2);
+  if (!plan) return void 0;
+  const { cut: cut2 } = plan;
+  const budget = compactBudget(contextTokens);
+  const system = messages[0];
+  const prompt = { role: "user", content: summaryPrompt(Math.floor(summaryReserve(budget) / 2)) };
+  const bounds = [1, ...safeCuts(messages).filter((c) => c > 1 && c < cut2), cut2];
+  const rounds = [];
+  for (let i = 0; i + 1 < bounds.length; i++) rounds.push(messages.slice(bounds[i], bounds[i + 1]));
   const before = conversationTokens(messages);
-  const turn = await client.chatStream(
-    [...messages.slice(0, cut2), { role: "user", content: SUMMARY_PROMPT }],
-    model,
-    // The `/effort` setting applies to every call on the model, a summary
-    // included: somebody who turned it down to save credits saves them here too.
-    { signal: opts.signal, effort: opts.effort }
-  );
-  const summary = messageText(turn.message).trim() || "(no summary returned)";
-  const compacted = [
-    messages[0],
-    { role: "user", content: `${SUMMARY_LEAD}${summary}` },
-    { role: "assistant", content: SUMMARY_ACK },
-    ...messages.slice(cut2)
-  ];
+  let summary;
+  let creditsCharged = 0;
+  let balance = 0;
+  let spendable;
+  let calls = 0;
+  let next = 0;
+  while (next < rounds.length) {
+    const room = Math.max(
+      1e3,
+      budget - requestTokens([system, prompt]) - (summary === void 0 ? 0 : requestTokens(withSummary(summary, [])))
+    );
+    let chunk = shrinkToFit(rounds[next++], room);
+    while (next < rounds.length) {
+      const round = rounds[next];
+      const left = room - requestTokens(chunk);
+      if (requestTokens(round) <= left) {
+        chunk = [...chunk, ...round];
+        next++;
+        continue;
+      }
+      if (requestTokens(round) > room && left >= room / 2) {
+        chunk = [...chunk, ...shrinkToFit(round, left)];
+        next++;
+      }
+      break;
+    }
+    const request = [system, ...summary === void 0 ? chunk : withSummary(summary, chunk), prompt];
+    let text = "";
+    for (let attempt = 0; attempt < 2 && !text; attempt++) {
+      const turn = await client.chatStream(request, model, { signal: opts.signal, effort: opts.effort });
+      calls++;
+      creditsCharged += turn.creditsCharged;
+      balance = turn.balance;
+      spendable = turn.spendable;
+      text = messageText(turn.message).trim();
+    }
+    if (!text) throw new Error("the model returned an empty summary, so the conversation was left as it was");
+    summary = text;
+  }
+  const tailMessages = messages.slice(cut2);
+  let final = summary ?? "";
+  const excess = requestTokens([system, ...withSummary(final, tailMessages)]) - budget;
+  if (excess > 0) {
+    const lead = { role: "user", content: final };
+    final = messageText(shrinkToFit([lead], Math.max(0, messageWeight(lead) - excess - 1))[0]);
+  }
+  const compacted = [system, ...withSummary(final, tailMessages)];
   return {
     messages: compacted,
-    summary,
-    creditsCharged: turn.creditsCharged,
-    balance: turn.balance,
-    ...turn.spendable ? { spendable: turn.spendable } : {},
+    summary: final,
+    creditsCharged,
+    balance,
+    ...spendable ? { spendable } : {},
     before,
-    after: conversationTokens(compacted)
+    after: conversationTokens(compacted),
+    calls
   };
 }
+var COMPACT_ADVICE = "The work done so far is kept. Run /compact to summarise the conversation, this task's steps included, then send a message to carry on. /clear starts over, and /model switches to a model that takes longer conversations.";
+function withCompactAdvice(refusal) {
+  const lines = refusal.split("\n");
+  if (lines.length === 3) return [lines[0], COMPACT_ADVICE, lines[2]].join("\n");
+  return [...lines, COMPACT_ADVICE].join("\n");
+}
+function compactionHelps(messages, contextTokens) {
+  const plan = planCompaction(messages, contextTokens);
+  return plan !== void 0 && plan.over && plan.fits;
+}
 
 // src/version.ts
 import { readFileSync as readFileSync6 } from "node:fs";
@@ -6979,6 +7155,7 @@ export {
   PremiumLockedError,
   LimitRefusalError,
   MaintenanceError,
+  PromptTooLongError,
   shortfallHeadline,
   AuthError,
   GatewayClient,
@@ -7063,6 +7240,8 @@ export {
   SUMMARY_LEAD,
   SUMMARY_ACK,
   compact,
+  withCompactAdvice,
+  compactionHelps,
   VERSION,
   VERSION_LABEL,
   isNewerVersion,

package/dist/clixad.mjs

@@ -54,7 +54,7 @@ import {
   takeConfigNotices,
   toolSchemaFor,
   usd
-} from "./chunk-CNLFGTYS.mjs";
+} from "./chunk-E7SAKAVQ.mjs";
 
 // src/tui/load.ts
 import * as nodeModule from "node:module";
@@ -133,7 +133,7 @@ async function withProductionReact(load) {
 }
 function loadTui() {
   boundInkCaches();
-  return withProductionReact(() => import("./tui-M5SJRCHM.mjs"));
+  return withProductionReact(() => import("./tui-2H2XRALC.mjs"));
 }
 
 // src/title.ts

package/dist/{tui-M5SJRCHM.mjs → tui-2H2XRALC.mjs}

@@ -18,6 +18,7 @@ import {
   NO_SEARCH_INSTRUCTION,
   PaywallError,
   PremiumLockedError,
+  PromptTooLongError,
   SPINNER_TICKS_PER_FRAME,
   SUMMARY_ACK,
   SUMMARY_LEAD,
@@ -35,6 +36,7 @@ import {
   colorEnabled,
   compact,
   compactBanner,
+  compactionHelps,
   contextTokensFor,
   conversationTokens,
   createPermit,
@@ -104,8 +106,9 @@ import {
   usd,
   visibleLength,
   webSearchCostLine,
-  welcomeBanner
-} from "./chunk-CNLFGTYS.mjs";
+  welcomeBanner,
+  withCompactAdvice
+} from "./chunk-E7SAKAVQ.mjs";
 
 // src/tui/index.tsx
 import "react";
@@ -2738,10 +2741,13 @@ function App({
       try {
         const window = contextWindow(model2);
         if (shouldCompact([{ role: "system", content: contextRef.current.systemPrompt }, ...history], window)) {
-          const res = await compact(client, model2, [
-            { role: "system", content: contextRef.current.systemPrompt },
-            ...history
-          ], { signal: ac.signal, effort: savedEffort(config, model2) });
+          const res = await compact(
+            client,
+            model2,
+            [{ role: "system", content: contextRef.current.systemPrompt }, ...history],
+            window,
+            { signal: ac.signal, effort: savedEffort(config, model2) }
+          );
           if (res) {
             history = res.messages.slice(1);
             setMessages(history);
@@ -2899,6 +2905,7 @@ ${preferencesText}` : ""),
           setMessages(kept);
           persist(kept);
         }
+        const compactAdvised = err instanceof PromptTooLongError && kept !== void 0 && compactionHelps([{ role: "system", content: contextRef.current.systemPrompt }, ...kept], contextWindow(model2));
         if ((err instanceof LimitRefusalError || err instanceof PremiumLockedError) && err.spendable) {
           balanceSeqRef.current++;
           takeSpendable(err.spendable.figures, err.spendable.balance);
@@ -2955,10 +2962,12 @@ ${preferencesText}` : ""),
           push({ kind: "notice", tone: "error", text: NOT_SIGNED_IN });
         } else if (err instanceof MaintenanceError) {
           push({ kind: "notice", tone: "warn", text: `  ${errorNotice(err.message, void 0, "  ")}` });
+        } else if (compactAdvised) {
+          push({ kind: "notice", tone: "error", text: `  error: ${errorNotice(withCompactAdvice(err.message), void 0, "  ")}` });
         } else {
           push({ kind: "notice", tone: "error", text: `  error: ${errorNotice(err.message, void 0, "  ")}` });
         }
-        if (kept && !(err instanceof PaywallError) && !(err instanceof PremiumLockedError)) {
+        if (kept && !(err instanceof PaywallError) && !(err instanceof PremiumLockedError) && !compactAdvised) {
           push({ kind: "notice", text: KEPT_AFTER_ERROR });
         }
       } finally {
@@ -3399,15 +3408,17 @@ ${preferencesText}` : ""),
           push({ kind: "notice", text: `  mode \u2192 ${MODE_LABEL[permRef.current.mode]}` });
           return;
         }
-        // A model call like any other, so esc has to stop it like any other —
-        // and stopping it costs nothing, since the summary only replaces the
-        // conversation once the call has come back whole.
+        // Model calls like any other, so esc has to stop them like any other.
+        // Stopping leaves the conversation as it was, since the summary only
+        // replaces it once every call has come back whole; a summary that took
+        // several calls has been charged for the ones already finished.
         case "compact":
           await runBusy(COMPACTING, async (signal) => {
             const res = await compact(
               client,
               model,
               [{ role: "system", content: contextRef.current.systemPrompt }, ...messagesRef.current],
+              contextWindow(model),
               { signal, effort: savedEffort(config, model) }
             );
             if (!res) return void push({ kind: "notice", text: "  nothing to compact yet" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clixad",
-  "version": "0.0.1-beta.48",
+  "version": "0.0.1-beta.49",
   "description": "Free AI coding agent in your terminal, funded by rewarded ads.",
   "license": "Apache-2.0",
   "type": "module",