pi-optchat 0.8.4 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "type": "module",
   "pi": {
     "extensions": [

package/src/compactor.ts

@@ -1,4 +1,5 @@
-import { clampThinkingLevel, type Api, type AssistantMessage, type Message, type Model } from '@earendil-works/pi-ai';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { clampThinkingLevel, isRetryableAssistantError, type Api, type AssistantMessage, type Message, type Model } from '@earendil-works/pi-ai';
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 import { COMPACT, compaction, IMPORT_GUIDANCE, tooLong } from './prompts.ts';
@@ -43,7 +44,8 @@ function primeFirst() {
 }
 /** The model is asked for 512 bytes; `accepted` is the longest line kept without a retry (the profile's summary size tolerance). */
 export function createCompressor(registry: ModelRegistry, choice: () => ModelChoice,
-  onUsage: (message: AssistantMessage) => void = () => {}, accepted = () => DEFAULT_SETTINGS.summaryAcceptBytes): Compressor {
+  onUsage: (message: AssistantMessage) => void = () => {}, accepted = () => DEFAULT_SETTINGS.summaryAcceptBytes,
+  retryDelays: readonly number[] = [1000, 2000]): Compressor {
   const gate = primeFirst();
   return async (input, signal) => {
     const selected = choice();
@@ -56,9 +58,8 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
     const view = splitView(input.context);
     const prefix = model.api === 'anthropic-messages' && view.length > 1 ? `${model.provider}/${model.id}/${thinking ?? 'off'}\n${view.slice(0, -1).join('')}` : undefined;
     const tries: string[] = [];
-    for (let attempt = 0; attempt < 5; attempt++) {
+    const ask = async () => {
       const warmed = prefix ? await gate(prefix, signal) : () => {};
-      let reply: AssistantMessage;
       try {
         const stream = registry.streamSimple(model, { systemPrompt: COMPACT, messages }, {
           // A shared session id is the OpenAI prompt-cache key; SSE because over a websocket Codex would chain unrelated parallel calls on one cached connection.
@@ -68,9 +69,20 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
         });
         // The cache entry is usable once the model starts answering.
         for await (const event of stream) if (event.type !== 'start') { warmed(event.type !== 'error'); break; }
-        reply = await stream.result();
+        return await stream.result();
       } finally { warmed(false); }
-      onUsage(reply);
+    };
+    // Pi's agent loop retries a dropped connection itself; streamSimple doesn't, so a transient error is asked again before it surfaces.
+    const answer = async () => {
+      for (let retry = 0; ; retry++) {
+        const reply = await ask();
+        onUsage(reply);
+        if (retry >= retryDelays.length || !isRetryableAssistantError(reply)) return reply;
+        await sleep(retryDelays[retry], undefined, { signal });
+      }
+    };
+    for (let attempt = 0; attempt < 5; attempt++) {
+      const reply = await answer();
       if (reply.stopReason === 'error' || reply.stopReason === 'aborted') throw new Error(reply.errorMessage ?? `Compactor ${reply.stopReason}`);
       // A reply cut off at the token limit, or one that calls a tool, is no summary: ask again.
       if (reply.stopReason === 'length' || reply.content.some(c => c.type === 'toolCall')) continue;

package/src/memory.ts

@@ -26,6 +26,7 @@ export const flat = (s: string) => s.replace(/[\r\n]+/g, ' ');
 const lineBytes = (s: string) => bytes(flat(s));
 const notice = (omitted: number) => `\n[${omitted} characters omitted; head and tail retained]\n`;
 const VIEW_OPEN = '<chat>\n';
+const VIEW_FRAME_BYTES = bytes(`${VIEW_OPEN}</chat>`);
 export const isView = (text: string) => text.startsWith(VIEW_OPEN);
 export function cap(text: string, limit = CAP) {
   if (text.length <= limit) return text;
@@ -51,10 +52,10 @@ export function mostDue(view: readonly Part[], total: number, built: (part: Part
 class Sawtooth {
   readonly parts: Part[] = [];
   private measured = 0;
-  private merging = false;
+  merging = false;
   constructor(private readonly high: number, private readonly low: number, private readonly node: (part: Part) => Summary | undefined) {}
-  private lineSize(part: Part) { return this.node(part)?.size ?? UNBUILT_BYTES; }
-  get size() { return this.measured; }
+  private lineSize(part: Part) { return bytes(`${start(part)}+${2 ** part.l}|\n`) + (this.node(part)?.size ?? UNBUILT_BYTES); }
+  get size() { return VIEW_FRAME_BYTES + this.measured + (this.parts.length ? 0 : 1); } // render() keeps a blank line in an empty view.
   push(part: Part) { this.parts.push(part); this.measured += this.lineSize(part); }
   /** The line covering message `at`. The lines tile the log in order, so a binary search finds it. */
   covering(at: number): Part | undefined {
@@ -66,17 +67,17 @@ class Sawtooth {
     }
   }
   /** A message got its node. Its line is usually still shown, but after a damaged tree file a saved parent can already hide it. */
-  built(i: number) { if (this.covering(i)?.l === 0) this.measured += this.lineSize({ l: 0, i }) - UNBUILT_BYTES; }
+  built(i: number) { if (this.covering(i)?.l === 0) this.measured += this.node({ l: 0, i })!.size - UNBUILT_BYTES; }
   /** Returns whether any lines merged. */
   fit(total: number, force = false) {
     const lines = this.parts.length;
-    if (force || this.measured > this.high) this.merging = true;
-    for (let best: number; this.merging && this.measured > this.low && (best = mostDue(this.parts, total, part => !!this.node(part))) >= 0;) {
+    if (force || this.size > this.high) this.merging = true;
+    for (let best: number; this.merging && this.size > this.low && (best = mostDue(this.parts, total, part => !!this.node(part))) >= 0;) {
       const a = this.parts[best], b = this.parts[best + 1], parent = { l: a.l + 1, i: a.i / 2 };
       this.measured += this.lineSize(parent) - this.lineSize(a) - this.lineSize(b);
       this.parts.splice(best, 2, parent);
     }
-    if (this.measured <= this.low) this.merging = false;
+    if (this.size <= this.low) this.merging = false;
     return this.parts.length < lines;
   }
 }
@@ -187,6 +188,8 @@ export class Memory {
     const rebuild = () => { this.warn('Rebuilt the memory view: the saved one does not match the log.'); return 0; };
     let saved: unknown;
     try { saved = JSON.parse(view); } catch { return rebuild(); }
+    const merging = object(saved) && saved.merging === true;
+    if (object(saved) && typeof saved.merging === 'boolean') saved = saved.parts;
     if (!Array.isArray(saved)) return rebuild();
     const parts: Part[] = [];
     let covered = 0;
@@ -198,13 +201,14 @@ export class Memory {
       parts.push(part); covered = end(part);
     }
     for (const part of parts) this.chat.push(part);
+    this.chat.merging = merging;
     return covered;
   }
-  /** Saved when it merges: a view that only grew is the saved one plus a line per later message, as `load` replays it.
+  /** Saved when it merges or changes batch state: a view that only grew is the saved one plus later messages, as `load` replays it.
    * The log stays authoritative, so a failed save only warns. */
   private save() {
     const failed = (error: unknown) => { this.warn(`Could not save the memory view: ${error instanceof Error ? error.message : String(error)}`); };
-    try { void this.enqueue(() => this.store.saveView(JSON.stringify(this.view.map(p => [p.l, p.i]))), failed); }
+    try { void this.enqueue(() => this.store.saveView(JSON.stringify({ parts: this.view.map(p => [p.l, p.i]), merging: this.chat.merging })), failed); }
     catch (error) { failed(error); }
   }
   private push(i: number) {
@@ -227,14 +231,15 @@ export class Memory {
   onChange(listener: () => void) { this.events.on('change', listener); return () => { this.events.off('change', listener); }; }
   /** The view line covering message `at`. */
   covering(at: number) { return this.chat.covering(at); }
-  /** Returns whether the chat's view merged. */
+  /** Returns whether the chat's view or batch state changed. */
   private fit(total = this.root.length) {
+    const merging = this.chat.merging;
     const merged = this.chat.fit(total);
     this.compaction.fit(total, merged);
     const owed = this.owed();
     this.peak = owed > 0 ? Math.max(this.peak, owed) : 0;
     this.events.emit('change');
-    return merged;
+    return merged || merging !== this.chat.merging;
   }
   private schedule() {
     if (this.scheduled || this.stopped) return;