claude-code-infinite 1.0.32 → 1.0.34

package/dist/memtree.js

@@ -23,6 +23,8 @@ import { usageDashboardUrl } from "./usage-link.js";
 import { extendsHistory, mediaFreeMessageHash } from "./route-identity.js";
 import { withShortPaymentUrl } from "./payment-gate.js";
 import { isKeyRejected, keyPageUrl } from "./key-page.js";
+import { indexWaitFrom413 } from "./index-wait-413.js";
+import { networkFailureOf } from "./network-failure.js";
 import { IMAGE_REFS_FEATURE, ImageRefs, MISSING_IMAGES_STATUS, missingImageShas, refusesImageRefs, } from "./image-refs.js";
 import { planMemtreeBody } from "./memtree-body.js";
 import { stripCcSystemReminders, } from "./turns.js";
@@ -48,8 +50,12 @@ const DEFAULT_COMPRESS_TIMEOUT_MS = 15000;
  * body (20+ MB) takes seconds to send on a slow link before the server even
  * starts, so a flat budget times out on size alone (2026-10-23: every tool
  * turn's compress of a 21.5 MB body timed out at 15 s with MemTree healthy).
+ * Measured from ccc's request logs, 2026-10-23..30: compress calls of 21-27 MB
+ * answered in 10-53 s (median ~19 s); at 1 ms/KiB a 26 MB call had ~41 s and lost
+ * to the 53 s ones, refusing a session for ten minutes (2026-10-30). 2.5 ms/KiB
+ * gives a 26 MB call ~79 s, 1.5x the slowest seen.
  */
-export const COMPRESS_TIMEOUT_MS_PER_KIB = 1;
+export const COMPRESS_TIMEOUT_MS_PER_KIB = 2.5;
 /**
  * The budget for a compress with nothing else to send: no compressed prefix to
  * ride and a raw request known not to fit the window (the first turn after
@@ -60,6 +66,13 @@ export const COMPRESS_TIMEOUT_MS_PER_KIB = 1;
 const DEFAULT_LONG_COMPRESS_TIMEOUT_MS = 120_000;
 /** Indexing runs off the response path; give it room. */
 const INDEX_TIMEOUT_MS = 120_000;
+/**
+ * New text (characters) a conversation's history must gain over its last index upload
+ * before the next one is sent: about the server's 10k-token index minimum
+ * (polychat MIN_TOKENS_TO_INDEX) at ~3 characters a token. Under it the server only
+ * acknowledges the upload.
+ */
+export const INDEX_MIN_NEW_CHARS = 30_000;
 const DEDUPE_CACHE_MAX = 64;
 /**
  * A main-lane Stop followed by this long without a new request is taken as the
@@ -774,6 +787,17 @@ export class MemtreeClient {
     indexLanesNext = new Map();
     /** Per conversation, the history the exit's final index carries (flushFinalIndexes). */
     finalIndexLanes = new Map();
+    indexMinNewChars;
+    compressTimeoutMsPerKiB;
+    /** Per conversation, the last history an index call was started for (INDEX_MIN_NEW_CHARS). */
+    indexLanesSent = new Map();
+    /**
+     * Per conversation, the newest history held back by INDEX_MIN_NEW_CHARS: sent before a
+     * call that does not carry it whole (a rewind, evicted media) replaces it.
+     */
+    indexLanesHeld = new Map();
+    /** Per conversation, the upload in flight: the baseline until it succeeds or fails. */
+    indexLanesPending = new Map();
     /** Once draining begins, no later request may create another log producer. */
     backgroundClosing = false;
     /** drainBackground ran out and is aborting what is left (exit_index_cut, not an error). */
@@ -797,10 +821,14 @@ export class MemtreeClient {
     lastAnswerKeyInvalid = false;
     /** Whether the latest such call succeeded; undefined before any answer. */
     lastAnswerOk;
+    /** The latest call's connection failure, until a later call gets any answer. */
+    lastUnreachable;
     /** Complete compression request key → whether its latest failure arms fuse. */
     compressFailureArming = new Map();
     /** HTTP status of each key's latest failed compress (absent: no response). */
     compressFailureStatus = new Map();
+    /** Seconds of indexing left, per compress call that MemTree answered with an indexing 413. */
+    compressIndexWaits = new WeakMap();
     /**
      * Non-null when the server last answered 402 (unpaid MemTree key): the
      * server's human-readable detail text. Set by both compression and
@@ -849,6 +877,13 @@ export class MemtreeClient {
     get answering() {
         return this.lastAnswerOk;
     }
+    /**
+     * The connection failure (DNS or connect) of the latest compress or prepare call that got
+     * no answer, while no later call got one; undefined once MemTree answers any call.
+     */
+    get unreachable() {
+        return this.lastUnreachable;
+    }
     /** Where to get a new key for this client's environment (its base URL). */
     get keyPageUrl() {
         return keyPageUrl(this.baseUrl);
@@ -867,7 +902,7 @@ export class MemtreeClient {
     }
     /** The blocking-compress budget for an upload of `bytes` (COMPRESS_TIMEOUT_MS_PER_KIB). */
     compressBudgetForBytes(bytes) {
-        return scaledTimeout(this.compressBudgetMs, bytes);
+        return scaledTimeout(this.compressBudgetMs, bytes, this.compressTimeoutMsPerKiB);
     }
     /**
      * When a compress call (not an index-only one) last got a live successful
@@ -926,6 +961,8 @@ export class MemtreeClient {
         this.longCompressTimeoutMs =
             opts.longCompressTimeoutMs ??
                 Number(process.env.CCC_COMPRESS_TIMEOUT_MS || DEFAULT_LONG_COMPRESS_TIMEOUT_MS);
+        this.indexMinNewChars = opts.indexMinNewChars ?? INDEX_MIN_NEW_CHARS;
+        this.compressTimeoutMsPerKiB = opts.compressTimeoutMsPerKiB ?? COMPRESS_TIMEOUT_MS_PER_KIB;
         this.debug = opts.debug ?? false;
         this.reqlog = opts.reqlog;
         this.memtreeTools = opts.memtreeTools || undefined;
@@ -974,6 +1011,14 @@ export class MemtreeClient {
     lastCompressFailureStatus(hash, modelContextLimit, meta) {
         return this.compressFailureStatus.get(this.compressKey(hash, modelContextLimit, meta));
     }
+    /**
+     * When the compress call `call` (as compress() returned it, joined or not) failed with
+     * MemTree's 413 for an index still catching up (index-wait-413.ts): the seconds of
+     * indexing it said were left. Undefined for any other outcome, or before it settles.
+     */
+    compressIndexWait(call) {
+        return this.compressIndexWaits.get(call);
+    }
     /**
      * Blocking user-turn compression. Returns null on ANY failure (timeout,
      * network, 4xx/5xx including 402) — the caller must degrade to passthrough.
@@ -1034,6 +1079,9 @@ export class MemtreeClient {
                 if (first !== undefined)
                     this.compressFailureStatus.delete(first);
             }
+            if (typeof err?.indexWaitSeconds === "number") {
+                this.compressIndexWaits.set(promise, err.indexWaitSeconds);
+            }
             // Don't cache failures — drop the entry so retries (e.g. Claude Code's
             // automatic retry of an identical request) hit the server again.
             if (this.compressCache.get(cacheKey) === promise) {
@@ -1087,19 +1135,36 @@ export class MemtreeClient {
      */
     indexInBackground(hash, messages, modelContextLimit, sessionId, clientMeta, 
     /** Times for retained original messages, in the positions actually sent. */
-    messageTimesFor) {
+    messageTimesFor, 
+    /**
+     * `force`: send even under INDEX_MIN_NEW_CHARS of new text. `finalIndex` (implies it):
+     * flagged final_index, so the server indexes the tail under its own minimum too; the
+     * server allows one per conversation per 30 minutes, so only at a subagent's end.
+     */
+    options = {}) {
         if (this.backgroundClosing)
             return;
-        const indexKey = JSON.stringify([sessionId ?? null, hash]);
+        // A final call is its own entry: the same history sent per turn may have left a tail.
+        const final = options.finalIndex === true;
+        const indexKey = JSON.stringify([sessionId ?? null, hash, ...(final ? ["final"] : [])]);
         if (this.indexedHashes.has(indexKey))
             return;
+        const lane = indexLaneKey(sessionId, messages);
+        const job = { messages, modelContextLimit,
+            opts: { sessionId, clientMeta, messageTimesFor, ...(final ? { finalIndex: true } : {}) } };
+        this.releaseHeldIndex(lane, job);
+        // Held back is not sent: a later (or forced) call of the same history still goes.
+        if (!options.force && !final && this.tooLittleNewText(lane, job)) {
+            this.holdIndex(lane, job);
+            return;
+        }
         this.indexedHashes.add(indexKey);
         if (this.indexedHashes.size > DEDUPE_CACHE_MAX) {
             const first = this.indexedHashes.values().next().value;
             if (first !== undefined)
                 this.indexedHashes.delete(first);
         }
-        this.enqueueIndex(indexLaneKey(sessionId, messages), { messages, modelContextLimit, opts: { sessionId, clientMeta, messageTimesFor } });
+        this.enqueueIndex(lane, job);
     }
     /**
      * At most one background index call per conversation. Each call carries the whole
@@ -1107,6 +1172,9 @@ export class MemtreeClient {
      * session's tool rounds otherwise stacked 25 MB uploads, up to 16 at once, and starved
      * the compress calls that share the link (long-session test, staging 2026-10-24). A
      * waiting call is replaced only by one whose history extends it; otherwise it goes now.
+     * A call whose history extends the last one sent by less than INDEX_MIN_NEW_CHARS of
+     * text is not sent at all: the server only acknowledges it (2026-10-30: 3 in 4 of a
+     * 23 MB session's index uploads, ~1 GB per 40 minutes).
      */
     enqueueIndex(lane, job) {
         if (!this.indexLanesBusy.has(lane)) {
@@ -1114,14 +1182,85 @@ export class MemtreeClient {
             return;
         }
         const waiting = this.indexLanesNext.get(lane);
-        if (waiting && !extendsHistory(job.messages, waiting.messages)) {
-            void this.submitIndexOnly(waiting.messages, waiting.modelContextLimit, waiting.opts);
+        // Not replaced when the new one does not carry it whole: another branch, media Claude
+        // Code evicted since (never uploaded otherwise), or a final call.
+        if (waiting && (!extendsHistory(job.messages, waiting.messages) ||
+            losesMedia(waiting.messages, job.messages) ||
+            (waiting.opts.finalIndex && !job.opts.finalIndex))) {
+            void this.sendLaneIndex(lane, waiting);
         }
         this.indexLanesNext.set(lane, job);
     }
+    /**
+     * Send `job` as its conversation's newest upload: the INDEX_MIN_NEW_CHARS baseline while
+     * it is in flight, and once it succeeded. A failed one is never a baseline, so the next
+     * turn is not held back by an upload the server never got.
+     */
+    sendLaneIndex(lane, job) {
+        const sent = { messages: job.messages, chars: messagesTextChars(job.messages) };
+        this.indexLanesPending.set(lane, sent);
+        return this.submitIndexOnly(job.messages, job.modelContextLimit, job.opts).then((ok) => {
+            if (this.indexLanesPending.get(lane) === sent)
+                this.indexLanesPending.delete(lane);
+            if (ok)
+                this.noteIndexSent(lane, sent);
+            return ok;
+        });
+    }
+    /**
+     * Before `job` goes or is held: the lane's held-back history is sent if `job` does not
+     * carry it whole (origin/main sent every turn, so a rewind must not lose a branch), and
+     * dropped otherwise (`job` carries it).
+     */
+    releaseHeldIndex(lane, job) {
+        const held = this.indexLanesHeld.get(lane);
+        if (!held)
+            return;
+        this.indexLanesHeld.delete(lane);
+        if (!extendsHistory(job.messages, held.messages) || losesMedia(held.messages, job.messages)) {
+            this.enqueueIndex(lane, held);
+        }
+    }
+    holdIndex(lane, job) {
+        this.indexLanesHeld.set(lane, job);
+        if (this.indexLanesHeld.size > DEDUPE_CACHE_MAX) {
+            // Over capacity the oldest held history is sent, not dropped (origin/main sent it).
+            const [first, evicted] = this.indexLanesHeld.entries().next().value;
+            this.indexLanesHeld.delete(first);
+            this.enqueueIndex(first, evicted);
+        }
+    }
+    /**
+     * Whether `job` adds under INDEX_MIN_NEW_CHARS of text to the history its conversation
+     * last sent (or has waiting to send): the server's index minimum would only ack it.
+     */
+    tooLittleNewText(lane, job) {
+        // A waiting call is replaced by this one anyway: it is never held back.
+        if (this.indexLanesNext.has(lane))
+            return false;
+        const sent = this.indexLanesPending.get(lane) ?? this.indexLanesSent.get(lane);
+        if (this.indexMinNewChars <= 0 || !sent || !extendsHistory(job.messages, sent.messages)) {
+            return false;
+        }
+        // An image or document carries no text but may be evicted by Claude Code before a
+        // later upload: never held back.
+        if (carriesMedia(job.messages.slice(sent.messages.length)))
+            return false;
+        return messagesTextChars(job.messages) - sent.chars < this.indexMinNewChars;
+    }
+    /** Record the history an index call of `lane` delivered. */
+    noteIndexSent(lane, sent) {
+        this.indexLanesSent.delete(lane);
+        this.indexLanesSent.set(lane, sent);
+        if (this.indexLanesSent.size > DEDUPE_CACHE_MAX) {
+            const first = this.indexLanesSent.keys().next().value;
+            if (first !== undefined)
+                this.indexLanesSent.delete(first);
+        }
+    }
     startLaneIndex(lane, job) {
         this.indexLanesBusy.add(lane);
-        void this.submitIndexOnly(job.messages, job.modelContextLimit, job.opts).finally(() => {
+        void this.sendLaneIndex(lane, job).finally(() => {
             this.indexLanesBusy.delete(lane);
             const next = this.indexLanesNext.get(lane);
             this.indexLanesNext.delete(lane);
@@ -1135,9 +1274,20 @@ export class MemtreeClient {
      * the final index carries (a main session's, unless it was rewound since).
      */
     sendWaitingIndexes() {
+        // A history held back by the text minimum goes too (origin/main sent every turn),
+        // unless a waiting call or the final index carries it.
+        // A carrier must hold the media too: extendsHistory tolerates media Claude Code evicted,
+        // which no later upload would carry (Codex r1 P0, release 1.0.33).
+        const carries = (carrier, messages) => carrier !== undefined && extendsHistory(carrier, messages) && !losesMedia(messages, carrier);
+        for (const [lane, held] of this.indexLanesHeld) {
+            const carriers = [this.indexLanesNext.get(lane)?.messages, this.finalIndexLanes.get(lane)];
+            if (!carriers.some((messages) => carries(messages, held.messages))) {
+                void this.submitIndexOnly(held.messages, held.modelContextLimit, held.opts);
+            }
+        }
+        this.indexLanesHeld.clear();
         for (const [lane, job] of this.indexLanesNext) {
-            const final = this.finalIndexLanes.get(lane);
-            if (!final || !extendsHistory(final, job.messages)) {
+            if (!carries(this.finalIndexLanes.get(lane), job.messages)) {
                 void this.submitIndexOnly(job.messages, job.modelContextLimit, job.opts);
             }
         }
@@ -1263,8 +1413,9 @@ export class MemtreeClient {
             sessionId: opts.sessionId,
             clientMeta: opts.clientMeta,
         })
-            .then(() => undefined, (err) => {
+            .then(() => true, (err) => {
             this.log(`background indexing failed (ignored): ${err?.message ?? err}`);
+            return false;
         })
             .finally(() => {
             this.backgroundIndexes.delete(operation);
@@ -1455,7 +1606,13 @@ export class MemtreeClient {
                 ? { value: opts.serializedMessages, refs: opts.serializedImageRefs ?? [] } : undefined,
             imageRefs: refs ? this.imageRefs : undefined,
         });
-        const planned = plan(opts.imageRefs !== false);
+        let planned = plan(opts.imageRefs !== false);
+        // A compress over the limit is not sent at all: before that, try it with images
+        // the server has not listed as references too (a resumed session's first call).
+        const unconfirmed = planned.payload === undefined && !opts.indexOnly &&
+            opts.imageRefs !== false ? this.planUnconfirmed(body, messages) : undefined;
+        if (unconfirmed)
+            planned = unconfirmed;
         if (planned.payload === undefined)
             throw this.oversized(planned.limit, opts);
         const payload = planned.payload;
@@ -1473,15 +1630,24 @@ export class MemtreeClient {
         // A default compress budget grows with what it uploads; an index call's,
         // and any budget a caller set, is fixed.
         const timeoutMs = opts.scaleTimeout && !opts.indexOnly
-            ? scaledTimeout(opts.timeoutMs, Buffer.byteLength(payload, "utf-8")) : opts.timeoutMs;
+            ? scaledTimeout(opts.timeoutMs, Buffer.byteLength(payload, "utf-8"), this.compressTimeoutMsPerKiB)
+            : opts.timeoutMs;
         const timeout = setTimeout(abort, timeoutMs);
         timeout.unref();
         opts.signal?.addEventListener("abort", abort, { once: true });
         if (opts.signal?.aborted)
             abort();
         try {
-            const response = await this.postContextMemory(payload, opts, controller.signal);
+            const response = await this.postRetryingDrop(payload, opts, controller.signal)
+                .catch((err) => {
+                // A background index call is no request's own evidence (review r1): it may clear
+                // the state by an answer, never set it.
+                if (!opts.indexOnly)
+                    this.noteUnreachable(err);
+                throw err;
+            });
             status = response.status;
+            this.lastUnreachable = undefined;
             if (planned.refs.length && !response.ok) {
                 refusalText = await readUnlessAborted(response, controller.signal);
                 if (this.refusedRefs(response.status, refusalText, planned.refs)) {
@@ -1491,8 +1657,12 @@ export class MemtreeClient {
                     // budget adds its allowance to what is left, however negative.
                     resent = true;
                     const budget = opts.timeoutMs;
+                    // Unconfirmed references the server named as missing: only those go as bytes
+                    // (all bytes would be over the limit again), once.
+                    const keepRefs = unconfirmed !== undefined && !opts.unconfirmedRetry &&
+                        namesMissingImages(response.status, refusalText);
                     return await this.callContextMemory(messages, modelContextLimit, {
-                        ...opts, imageRefs: false,
+                        ...opts, ...(keepRefs ? { unconfirmedRetry: true } : { imageRefs: false }),
                         get timeoutMs() { return budget - (Date.now() - started); },
                     });
                 }
@@ -1507,9 +1677,15 @@ export class MemtreeClient {
                 keyRefused = isKeyRejected(response.status, text);
                 // The status rides on the error so compress() can classify the
                 // failure for the fuse without parsing message text.
-                throw Object.assign(new Error(`context_memory ${response.status}: ${text.slice(0, 300)}`), { status: response.status });
+                throw Object.assign(new Error(`context_memory ${response.status}: ${text.slice(0, 300)}`), { status: response.status,
+                    indexWaitSeconds: indexWaitFrom413(response.status, text, response.headers.get("retry-after"), Date.now(), response.headers.get("x-polychat-index-pending")) });
             }
             const json = (await response.json());
+            if (unconfirmed && !ImageRefs.resolvedBy(json)) {
+                // No proof the server put the images back: its result may hold references.
+                this.imageRefs.disable();
+                throw new Error("context_memory answer does not show it resolves image references");
+            }
             this.imageRefs.noteAnswer(json);
             // An index-only ack is `{ messages: [], usage: {...zeros}, index_only:
             // true }` by contract: the server skips compression and returns no
@@ -1578,6 +1754,7 @@ export class MemtreeClient {
                     status,
                     requestBytes: Buffer.byteLength(payload),
                     ...(planned.limit ? { bodyLimit: planned.limit } : {}),
+                    ...(unconfirmed ? { unconfirmedImageRefs: unconfirmed.refs.length } : {}),
                     // Aborted by an exit drain that ran out: a known cut, not a server failure.
                     ...(!ok && this.drainCutting && controller.signal.aborted
                         ? { exitCut: true, finalIndex: opts.finalIndex === true }
@@ -1590,13 +1767,56 @@ export class MemtreeClient {
                 });
         }
     }
-    /** One POST of a MemTree call's body. */
-    postContextMemory(payload, opts, signal) {
+    /** Remember a call's connection failure (memtree.unreachable); other errors are no news. */
+    noteUnreachable(err) {
+        const failure = networkFailureOf(err, URL.canParse(this.baseUrl)
+            ? new URL(this.baseUrl).host : this.baseUrl);
+        if (failure)
+            this.lastUnreachable = failure;
+    }
+    /**
+     * A compress or prepare call's POST, sent once more (within the same budget) when its
+     * connection dropped while the body was still uploading: a Wi-Fi switch cut a 24 MB
+     * upload with EHOSTUNREACH after 89 s, ~1 MB sent (2026-10-28), and the turn went without
+     * memory. Only before the whole body was handed over: after that MemTree may already be
+     * compressing (and billing) it, and a second call would be a second compression.
+     * Index-only calls are not retried: the next turn sends their history again.
+     */
+    async postRetryingDrop(payload, opts, signal) {
+        const upload = { done: false };
+        try {
+            return await this.postContextMemory(payload, opts, signal, opts.indexOnly ? undefined : upload);
+        }
+        catch (err) {
+            if (opts.indexOnly || signal.aborted)
+                throw err;
+            // A 401 to a streamed body: fetch reports a network error, not the status. A 401
+            // compresses nothing (nothing billed): sent again whole, its status is seen.
+            if (isStreamedBodyAuthChallenge(err)) {
+                return await this.postContextMemory(payload, opts, signal);
+            }
+            if (upload.done || !isDroppedConnection(err))
+                throw err;
+            this.log(`context_memory upload dropped (${droppedCode(err)}); retrying once`);
+            return await this.postContextMemory(payload, opts, signal);
+        }
+    }
+    /**
+     * One POST of a MemTree call's body. With `upload`, a body of STREAMED_UPLOAD_MIN_BYTES
+     * or more goes as a stream and `upload.done` turns true once its last byte was handed
+     * over (a smaller one counts as handed over at once).
+     */
+    postContextMemory(payload, opts, signal, upload) {
+        const bytes = Buffer.from(payload, "utf-8");
+        const streamed = upload !== undefined && bytes.length >= STREAMED_UPLOAD_MIN_BYTES;
+        if (upload && !streamed)
+            upload.done = true;
         return fetch(`${this.baseUrl}/v1/context_memory`, {
             method: "POST",
             headers: {
                 authorization: `Bearer ${this.apiKey}`,
                 "content-type": "application/json",
+                ...(streamed ? { "content-length": String(bytes.length) } : {}),
                 "x-client": CLIENT_NAME,
                 "x-client-version": CLIENT_VERSION,
                 "x-client-features": CLIENT_FEATURES,
@@ -1609,7 +1829,8 @@ export class MemtreeClient {
                     ? { "x-memtree-tools": this.memtreeTools }
                     : {}),
             },
-            body: payload,
+            body: streamed ? uploadStream(bytes, upload) : payload,
+            ...(streamed ? { duplex: "half" } : {}),
             signal,
         });
     }
@@ -1623,6 +1844,7 @@ export class MemtreeClient {
         const refused = refusesImageRefs(status, text);
         if (missing !== undefined) {
             this.imageRefs.forget(missing.length ? missing : refs);
+            this.imageRefs.noteMissing(missing);
         }
         else if (refused === "never") {
             this.imageRefs.disable();
@@ -1636,6 +1858,19 @@ export class MemtreeClient {
         this.log(`context_memory ${status} on image references: sending their bytes`);
         return true;
     }
+    /**
+     * `body` with every image the server has not said it lacks as a reference, when
+     * that fits the limit (image-refs.ts: referenceUnconfirmed); undefined otherwise.
+     */
+    planUnconfirmed(body, messages) {
+        const referenced = this.imageRefs.referenceUnconfirmed(messages);
+        const planned = referenced.refs.length
+            ? planMemtreeBody({ body, messages: referenced.value, indexOnly: false }) : undefined;
+        if (planned?.payload !== undefined)
+            return { ...planned, refs: referenced.refs };
+        this.imageRefs.retryMissing();
+        return undefined;
+    }
     /**
      * A body over the limit that nothing could shrink (memtree-body.ts): never sent.
      * Logged like any call, with `bodyLimit` (memtree_body_limit, not memtree_error); the
@@ -1654,6 +1889,10 @@ export class MemtreeClient {
             console.error(`[ccc proxy] ${msg}`);
     }
 }
+/** A 409 that names the references it could not serve (not one refusing them all). */
+function namesMissingImages(status, text) {
+    return status === MISSING_IMAGES_STATUS && (missingImageShas(text)?.length ?? 0) > 0;
+}
 /** A failed answer's body; an abort while reading it is thrown, never read as "". */
 async function readUnlessAborted(response, signal) {
     const text = await response.text().catch(() => "");
@@ -1685,11 +1924,133 @@ export function withFinalReply(messages, reply) {
 function callerCut(status) {
     return status === undefined || (status >= 200 && status < 300);
 }
+/** Connection-level failures a compress call is retried once after (postRetryingDrop). */
+const DROPPED_CONNECTION_CODES = new Set([
+    "ECONNRESET", "EHOSTUNREACH", "ENETUNREACH", "ENETDOWN", "EPIPE", "ECONNABORTED",
+    "ETIMEDOUT", "EAI_AGAIN", "UND_ERR_SOCKET", "ECONNREFUSED",
+]);
+/** Bodies from this size are streamed, so a drop can be told to come before their end. */
+const STREAMED_UPLOAD_MIN_BYTES = 1024 * 1024;
+const UPLOAD_CHUNK_BYTES = 256 * 1024;
+/** undici's message for a 401/407 answer to a body it cannot send again. */
+const STREAMED_BODY_AUTH_ERROR = /non-null body source/;
+/** `bytes` as a stream that sets `upload.done` once its last chunk was taken. */
+function uploadStream(bytes, upload) {
+    let offset = 0;
+    return new ReadableStream({
+        pull(controller) {
+            if (offset >= bytes.length) {
+                upload.done = true;
+                controller.close();
+                return;
+            }
+            const end = Math.min(bytes.length, offset + UPLOAD_CHUNK_BYTES);
+            controller.enqueue(bytes.subarray(offset, end));
+            offset = end;
+            if (offset >= bytes.length)
+                upload.done = true;
+        },
+    });
+}
+/** Whether a failed fetch lost its connection (the error's or its cause's code). */
+export function isDroppedConnection(err) {
+    const code = droppedCode(err);
+    return code !== undefined && DROPPED_CONNECTION_CODES.has(code);
+}
+/**
+ * Whether fetch failed a streamed body on a 401 (or 407) answer: the fetch standard turns
+ * those into a network error ("expected non-null body source") when the body cannot be
+ * replayed, so a revoked key would otherwise read as a lost connection.
+ */
+function isStreamedBodyAuthChallenge(err) {
+    const cause = err?.cause;
+    return cause?.code === undefined && typeof cause?.message === "string" &&
+        STREAMED_BODY_AUTH_ERROR.test(cause.message);
+}
+function droppedCode(err) {
+    const own = err?.code;
+    if (typeof own === "string")
+        return own;
+    const cause = err?.cause?.code;
+    return typeof cause === "string" ? cause : undefined;
+}
+/**
+ * The text a history carries, in characters: strings and text blocks, tool inputs and
+ * results; images and documents (base64) count nothing. For INDEX_MIN_NEW_CHARS only.
+ */
+export function messagesTextChars(messages) {
+    let chars = 0;
+    for (const message of messages)
+        chars += contentTextChars(message.content);
+    return chars;
+}
+/** Whether `messages` hold an image or document block (at any depth). */
+function carriesMedia(value) {
+    return mediaKeys(value).size > 0;
+}
+/**
+ * Whether `older` holds an image or document `newer` does not (Claude Code evicted it):
+ * replacing `older` by `newer` would leave it never uploaded.
+ */
+export function losesMedia(older, newer) {
+    const kept = mediaKeys(older);
+    if (kept.size === 0)
+        return false;
+    const now = mediaKeys(newer);
+    for (const key of kept)
+        if (!now.has(key))
+            return true;
+    return false;
+}
+/** A digest of each image and document block's source in `value`, at any depth. */
+function mediaKeys(value, keys = new Set()) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            mediaKeys(item, keys);
+        return keys;
+    }
+    if (!value || typeof value !== "object")
+        return keys;
+    const block = value;
+    if (block.type === "image" || block.type === "document") {
+        keys.add(createHash("sha256").update(JSON.stringify(block.source ?? block)).digest("hex"));
+    }
+    else if (Array.isArray(block.content)) {
+        mediaKeys(block.content, keys);
+    }
+    return keys;
+}
+function contentTextChars(value) {
+    if (typeof value === "string")
+        return value.length;
+    if (Array.isArray(value)) {
+        let chars = 0;
+        for (const item of value)
+            chars += contentTextChars(item);
+        return chars;
+    }
+    if (!value || typeof value !== "object")
+        return 0;
+    const block = value;
+    if (block.type === "image" || block.type === "document")
+        return 0;
+    if (typeof block.text === "string")
+        return block.text.length;
+    if (typeof block.thinking === "string")
+        return block.thinking.length;
+    if (block.content !== undefined)
+        return contentTextChars(block.content);
+    if (block.input !== undefined)
+        return JSON.stringify(block.input)?.length ?? 0;
+    return 0;
+}
 /** `baseMs` plus COMPRESS_TIMEOUT_MS_PER_KIB per KiB of `bytes`. */
-function scaledTimeout(baseMs, bytes) {
+function scaledTimeout(baseMs, bytes, perKiB) {
     if (!Number.isFinite(baseMs))
         return baseMs;
-    return baseMs + Math.ceil(Math.max(0, bytes) / 1024) * COMPRESS_TIMEOUT_MS_PER_KIB;
+    // Whole milliseconds: timers truncate a fractional delay, and a call that ran its whole
+    // budget must not measure as shorter than it (the proxy's timedOut check).
+    return baseMs + Math.ceil(Math.ceil(Math.max(0, bytes) / 1024) * perKiB);
 }
 /**
  * One conversation for background indexing: its session and its first message after the