claude-code-infinite 1.0.29 → 1.0.31

package/dist/memtree.js

@@ -20,17 +20,21 @@ import { createHash } from "node:crypto";
 import { prepareFinalMessages, readFinalReply } from "./final-index.js";
 import { createRequire } from "node:module";
 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 { IMAGE_REFS_FEATURE, ImageRefs, MISSING_IMAGES_STATUS, missingImageShas, refusesImageRefs, } from "./image-refs.js";
+import { planMemtreeBody } from "./memtree-body.js";
 import { stripCcSystemReminders, } from "./turns.js";
 export const CLIENT_NAME = "cc-infinite";
 /**
- * Sent as `x-client-features` on compress calls. `near-window-budget`: ccc lifts
+ * Sent as `x-client-features` on every MemTree call. `near-window-budget`: ccc lifts
  * Claude Code's local refusal near the window (claude-env.ts) and compresses
  * mid-turn, so the server may give it the 900k budget on 1M-window models
- * (older ccc keeps 800k).
+ * (older ccc keeps 800k). `image-refs`: ccc reads the stored images an answer
+ * lists and sends those images as references afterwards (image-refs.ts).
  */
-export const CLIENT_FEATURES = "near-window-budget";
+export const CLIENT_FEATURES = `near-window-budget,${IMAGE_REFS_FEATURE}`;
 // Sent on every MemTree call so the server can detect/warn stale clients
 // (plan: "API versioning").
 export const CLIENT_VERSION = createRequire(import.meta.url)("../package.json").version;
@@ -39,6 +43,13 @@ export const CLIENT_VERSION = createRequire(import.meta.url)("../package.json").
 // server-side compression — so this is a circuit breaker for a hung server, not a
 // latency target. Override via CCC_COMPRESS_TIMEOUT_MS (read below).
 const DEFAULT_COMPRESS_TIMEOUT_MS = 15000;
+/**
+ * Added to a compress call's budget per KiB of its upload: a large session's
+ * 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).
+ */
+export const COMPRESS_TIMEOUT_MS_PER_KIB = 1;
 /**
  * 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
@@ -736,6 +747,7 @@ export class MemtreeClient {
     baseUrl;
     apiKey;
     compressTimeoutMs;
+    compressSuccessAt = 0;
     longCompressTimeoutMs;
     debug;
     reqlog;
@@ -756,8 +768,18 @@ export class MemtreeClient {
     indexedHashes = new Set();
     /** In-flight index-only calls, tracked so shutdown cannot outrun their logs. */
     backgroundIndexes = new Map();
+    /** Conversations (indexLaneKey) with a background index call in flight. */
+    indexLanesBusy = new Set();
+    /** Per busy conversation, the newest index call waiting for the one in flight. */
+    indexLanesNext = new Map();
+    /** Per conversation, the history the exit's final index carries (flushFinalIndexes). */
+    finalIndexLanes = 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). */
+    drainCutting = false;
+    /** Images MemTree stores, sent as references instead of their bytes. */
+    imageRefs = new ImageRefs();
     /** Session → its main lane's latest conversation, for the final index. */
     mainConversations = new Map();
     /** Session → its final index waiting for the session to stay idle. */
@@ -773,8 +795,12 @@ export class MemtreeClient {
     lastAnswerUnpaid = false;
     /** Whether the latest call that got an answer, or timed out, refused the key (key-page.ts). */
     lastAnswerKeyInvalid = false;
+    /** Whether the latest such call succeeded; undefined before any answer. */
+    lastAnswerOk;
     /** 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();
     /**
      * Non-null when the server last answered 402 (unpaid MemTree key): the
      * server's human-readable detail text. Set by both compression and
@@ -792,6 +818,10 @@ export class MemtreeClient {
     get pausedDetail() {
         return this.lastAnswerUnpaid ? this.withShortLink(this.unpaidDetail) : null;
     }
+    /** Why the key is paused (payment-link.ts REASON_*) while a fresh short link says, else null. */
+    get pausedReason() {
+        return this.paymentLinks?.current()?.reason ?? null;
+    }
     /**
      * Wait at most `ms` for a short checkout link already being fetched, so a
      * notice about to be built from the 402 detail can show it. Never throws.
@@ -812,6 +842,13 @@ export class MemtreeClient {
     get keyInvalid() {
         return this.lastAnswerKeyInvalid;
     }
+    /**
+     * Whether MemTree's latest answer (or timeout) was a success: true, a
+     * failure: false, no answer yet: undefined. Positive evidence that it works.
+     */
+    get answering() {
+        return this.lastAnswerOk;
+    }
     /** Where to get a new key for this client's environment (its base URL). */
     get keyPageUrl() {
         return keyPageUrl(this.baseUrl);
@@ -828,6 +865,18 @@ export class MemtreeClient {
     get compressBudgetMs() {
         return this.compressTimeoutMs;
     }
+    /** The blocking-compress budget for an upload of `bytes` (COMPRESS_TIMEOUT_MS_PER_KIB). */
+    compressBudgetForBytes(bytes) {
+        return scaledTimeout(this.compressBudgetMs, bytes);
+    }
+    /**
+     * When a compress call (not an index-only one) last got a live successful
+     * answer (epoch ms; 0: never). A compress timing out while others succeed
+     * is its size or a slow reply, not an outage.
+     */
+    get lastCompressSuccessAt() {
+        return this.compressSuccessAt;
+    }
     /**
      * Non-secret identity of the MemTree backend and account this client uses:
      * a hash over the origin and a hash of the key. Persisted state is valid only
@@ -918,6 +967,13 @@ export class MemtreeClient {
     lastCompressFailureArming(hash, modelContextLimit, meta) {
         return (this.compressFailureArming.get(this.compressKey(hash, modelContextLimit, meta)) ?? true);
     }
+    /**
+     * The HTTP status of the latest failed compress of this request, sampled at
+     * its settle like lastCompressFailureArming; undefined when it got none.
+     */
+    lastCompressFailureStatus(hash, modelContextLimit, meta) {
+        return this.compressFailureStatus.get(this.compressKey(hash, modelContextLimit, meta));
+    }
     /**
      * Blocking user-turn compression. Returns null on ANY failure (timeout,
      * network, 4xx/5xx including 402) — the caller must degrade to passthrough.
@@ -935,11 +991,15 @@ export class MemtreeClient {
         const inFlightKey = this.inFlightKey(hash, modelContextLimit, meta);
         const promise = this.callContextMemory(messages, modelContextLimit, {
             timeoutMs: meta?.timeoutMs ?? this.compressTimeoutMs,
+            // An explicit budget is the caller's deadline (a preparation's waiters,
+            // the proxy's own wait): kept as given so both end together.
+            scaleTimeout: meta?.timeoutMs === undefined,
             signal,
             model: meta?.model,
             tools: meta?.tools,
             compressionTargetTokens: meta?.compressionTargetTokens,
             compressionThresholdTokens: meta?.compressionThresholdTokens,
+            prepare: meta?.prepare,
             clientInputTokens: meta?.clientInputTokens,
             clientInputTokensExact: meta?.clientInputTokensExact,
             messageUsage: meta?.messageUsage,
@@ -963,6 +1023,17 @@ export class MemtreeClient {
                 if (first !== undefined)
                     this.compressFailureArming.delete(first);
             }
+            this.compressFailureStatus.delete(cacheKey);
+            // A body never sent (over the limit) is no answer of the server's: its 413 must not
+            // read as MemTree's refusal to fit the window, which lets the safety net truncate.
+            if (status !== undefined && err?.bodyLimit !== true) {
+                this.compressFailureStatus.set(cacheKey, status);
+            }
+            if (this.compressFailureStatus.size > DEDUPE_CACHE_MAX) {
+                const first = this.compressFailureStatus.keys().next().value;
+                if (first !== undefined)
+                    this.compressFailureStatus.delete(first);
+            }
             // 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) {
@@ -1028,7 +1099,49 @@ export class MemtreeClient {
             if (first !== undefined)
                 this.indexedHashes.delete(first);
         }
-        this.submitIndexOnly(messages, modelContextLimit, { sessionId, clientMeta, messageTimesFor });
+        this.enqueueIndex(indexLaneKey(sessionId, messages), { messages, modelContextLimit, opts: { sessionId, clientMeta, messageTimesFor } });
+    }
+    /**
+     * At most one background index call per conversation. Each call carries the whole
+     * history, so while one uploads only the newest waiting call is worth sending: a long
+     * 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.
+     */
+    enqueueIndex(lane, job) {
+        if (!this.indexLanesBusy.has(lane)) {
+            this.startLaneIndex(lane, job);
+            return;
+        }
+        const waiting = this.indexLanesNext.get(lane);
+        if (waiting && !extendsHistory(job.messages, waiting.messages)) {
+            void this.submitIndexOnly(waiting.messages, waiting.modelContextLimit, waiting.opts);
+        }
+        this.indexLanesNext.set(lane, job);
+    }
+    startLaneIndex(lane, job) {
+        this.indexLanesBusy.add(lane);
+        void this.submitIndexOnly(job.messages, job.modelContextLimit, job.opts).finally(() => {
+            this.indexLanesBusy.delete(lane);
+            const next = this.indexLanesNext.get(lane);
+            this.indexLanesNext.delete(lane);
+            // At shutdown drainBackground has already sent (or dropped) what was waiting.
+            if (next && !this.backgroundClosing)
+                this.startLaneIndex(lane, next);
+        });
+    }
+    /**
+     * At shutdown: send every waiting call now, inside the drain, except one whose history
+     * the final index carries (a main session's, unless it was rewound since).
+     */
+    sendWaitingIndexes() {
+        for (const [lane, job] of this.indexLanesNext) {
+            const final = this.finalIndexLanes.get(lane);
+            if (!final || !extendsHistory(final, job.messages)) {
+                void this.submitIndexOnly(job.messages, job.modelContextLimit, job.opts);
+            }
+        }
+        this.indexLanesNext.clear();
     }
     /**
      * The main lane's latest conversation for a session, kept for its final
@@ -1078,8 +1191,13 @@ export class MemtreeClient {
             return;
         this.finalDrainDeadline ??= Date.now() + Math.max(0, timeoutMs);
         const recent = [...this.mainConversations.keys()].slice(-FINAL_INDEX_EXIT_SESSIONS).reverse();
-        for (const sessionId of recent)
+        for (const sessionId of recent) {
+            const conversation = this.mainConversations.get(sessionId);
+            if (conversation) {
+                this.finalIndexLanes.set(indexLaneKey(sessionId, conversation.messages), conversation.messages);
+            }
             this.fireFinalIndex(sessionId, true);
+        }
         for (const sessionId of this.pendingFinals.keys())
             this.cancelFinalIndex(sessionId);
     }
@@ -1110,7 +1228,7 @@ export class MemtreeClient {
     }
     async sendFinalIndex(sessionId, conversation, reader, signal) {
         const reply = await readFinalReply(reader, signal);
-        const prepared = await prepareFinalMessages(withFinalReply(conversation.messages, reply), signal);
+        const prepared = await prepareFinalMessages(withFinalReply(conversation.messages, reply), signal, (message) => this.imageRefs.referenceMessage(message));
         if (this.mainConversations.get(sessionId) !== conversation ||
             this.finalIndexed.get(sessionId) === prepared.key)
             return;
@@ -1120,7 +1238,7 @@ export class MemtreeClient {
         await this.callContextMemory(prepared.messages, conversation.modelContextLimit, {
             sessionId, clientMeta: conversation.clientMeta, messageTimes,
             indexOnly: true, finalIndex: true, signal, timeoutMs: INDEX_TIMEOUT_MS,
-            serializedMessages: prepared.serialized,
+            serializedMessages: prepared.serialized, serializedImageRefs: prepared.refs,
         });
     }
     submitIndexOnly(messages, modelContextLimit, opts) {
@@ -1152,7 +1270,7 @@ export class MemtreeClient {
             this.backgroundIndexes.delete(operation);
         });
         this.backgroundIndexes.set(operation, controller);
-        void operation;
+        return operation;
     }
     /**
      * Stop accepting background indexes and wait boundedly for those already in
@@ -1161,7 +1279,10 @@ export class MemtreeClient {
      * The boolean is true for a graceful drain and false when abort was needed.
      */
     async drainBackground(timeoutMs = 2_000) {
-        this.backgroundClosing = true;
+        if (!this.backgroundClosing) {
+            this.backgroundClosing = true;
+            this.sendWaitingIndexes();
+        }
         if (this.backgroundIndexes.size === 0)
             return true;
         const boundedMs = Number.isFinite(timeoutMs) && timeoutMs >= 0
@@ -1181,6 +1302,7 @@ export class MemtreeClient {
             clearTimeout(timer);
         if (completed)
             return true;
+        this.drainCutting = true;
         for (const controller of this.backgroundIndexes.values()) {
             controller.abort();
         }
@@ -1216,6 +1338,7 @@ export class MemtreeClient {
             meta?.compressionTargetTokens ?? null,
             meta?.compressionThresholdTokens ?? null,
             meta?.clientInputTokens !== undefined && meta.clientInputTokensExact === true,
+            meta?.prepare === true,
         ];
     }
     /**
@@ -1300,6 +1423,8 @@ export class MemtreeClient {
             if (opts.compressionThresholdTokens !== undefined) {
                 body.compression_threshold_tokens = opts.compressionThresholdTokens;
             }
+            if (opts.prepare)
+                body.prepare = true;
             if (opts.clientInputTokens !== undefined) {
                 body.client_input_tokens = opts.clientInputTokens;
                 if (opts.clientInputTokensExact)
@@ -1323,14 +1448,20 @@ export class MemtreeClient {
             // (within its image allowance) instead of naming them in placeholders.
             body.flatten_images = true;
         }
-        let payload;
-        if (opts.serializedMessages !== undefined) {
-            delete body.messages;
-            payload = JSON.stringify(body).slice(0, -1) + ',"messages":' + opts.serializedMessages + "}";
-        }
-        else {
-            payload = JSON.stringify(body);
-        }
+        // Stored images as references, and never a body over the HTTP/1 limit (memtree-body.ts).
+        const plan = (refs) => planMemtreeBody({
+            body, messages, indexOnly: opts.indexOnly === true,
+            serialized: refs && opts.serializedMessages !== undefined
+                ? { value: opts.serializedMessages, refs: opts.serializedImageRefs ?? [] } : undefined,
+            imageRefs: refs ? this.imageRefs : undefined,
+        });
+        const planned = plan(opts.imageRefs !== false);
+        if (planned.payload === undefined)
+            throw this.oversized(planned.limit, opts);
+        const payload = planned.payload;
+        // The answer named references it could not serve: sent again as its own call.
+        let resent = false;
+        let refusalText;
         opts.signal?.throwIfAborted();
         const started = Date.now();
         let status;
@@ -1339,35 +1470,35 @@ export class MemtreeClient {
         let diagnostics = {};
         const controller = new AbortController();
         const abort = () => controller.abort();
-        const timeout = setTimeout(abort, opts.timeoutMs);
+        // 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;
+        const timeout = setTimeout(abort, timeoutMs);
         timeout.unref();
         opts.signal?.addEventListener("abort", abort, { once: true });
         if (opts.signal?.aborted)
             abort();
         try {
-            const response = await fetch(`${this.baseUrl}/v1/context_memory`, {
-                method: "POST",
-                headers: {
-                    authorization: `Bearer ${this.apiKey}`,
-                    "content-type": "application/json",
-                    "x-client": CLIENT_NAME,
-                    "x-client-version": CLIENT_VERSION,
-                    "x-client-features": CLIENT_FEATURES,
-                    ...(opts.sessionId ? { "x-claude-code-session-id": opts.sessionId } : {}),
-                    ...(opts.clientMeta && Object.keys(opts.clientMeta).length
-                        ? { "x-client-meta": JSON.stringify(opts.clientMeta) }
-                        : {}),
-                    // Compress calls only: an index-only call returns no memory.
-                    ...(this.memtreeTools && !opts.indexOnly
-                        ? { "x-memtree-tools": this.memtreeTools }
-                        : {}),
-                },
-                body: payload,
-                signal: controller.signal,
-            });
+            const response = await this.postContextMemory(payload, opts, controller.signal);
             status = response.status;
+            if (planned.refs.length && !response.ok) {
+                refusalText = await readUnlessAborted(response, controller.signal);
+                if (this.refusedRefs(response.status, refusalText, planned.refs)) {
+                    // A new call with bytes: its own size and request-log record, within what is
+                    // left of this call's budget (a caller's deadline is never extended). Read when
+                    // its timer starts, after its body is built, and never clamped: a size-scaled
+                    // budget adds its allowance to what is left, however negative.
+                    resent = true;
+                    const budget = opts.timeoutMs;
+                    return await this.callContextMemory(messages, modelContextLimit, {
+                        ...opts, imageRefs: false,
+                        get timeoutMs() { return budget - (Date.now() - started); },
+                    });
+                }
+            }
             if (!response.ok) {
-                const text = await response.text().catch(() => "");
+                const text = refusalText ?? await response.text().catch(() => "");
                 if (response.status === 402) {
                     this.unpaidDetail = extract402Detail(text);
                     // Shared, cached and backed off: one request per hour at most while paused.
@@ -1379,6 +1510,7 @@ export class MemtreeClient {
                 throw Object.assign(new Error(`context_memory ${response.status}: ${text.slice(0, 300)}`), { status: response.status });
             }
             const json = (await response.json());
+            this.imageRefs.noteAnswer(json);
             // An index-only ack is `{ messages: [], usage: {...zeros}, index_only:
             // true }` by contract: the server skips compression and returns no
             // messages. Only a compress call needs a non-empty conversation back.
@@ -1393,6 +1525,8 @@ export class MemtreeClient {
             const memtreeIndex = response.headers.get("x-polychat-memtree-index") ?? undefined;
             this.unpaidDetail = null; // a success proves the key is paid (again)
             ok = true;
+            if (!opts.indexOnly)
+                this.compressSuccessAt = Date.now();
             diagnostics = {
                 ...(memtreeUrl ? { memtreeUrl } : {}),
                 ...(memtreeIndex ? { memtreeIndex } : {}),
@@ -1425,33 +1559,107 @@ export class MemtreeClient {
             // A background index call that failed otherwise (a timeout, a 413 on a big
             // body) is no news about payment; a compress call's answer always is.
             // A refused key is news from any call, like a 402.
-            const news = status === 402 || keyRefused || ok || !opts.indexOnly;
+            const news = !resent && (status === 402 || keyRefused || ok || !opts.indexOnly);
             if (news && (status !== undefined || !opts.signal?.aborted)) {
                 this.lastAnswerUnpaid = status === 402;
                 this.lastAnswerKeyInvalid = keyRefused;
             }
+            // Availability, unlike payment, counts a failed background index too.
+            if (!resent && (status !== undefined || !opts.signal?.aborted))
+                this.lastAnswerOk = ok;
             // One JSONL line per MemTree call, success or failure; `status` stays
             // absent when the call never got a response (network error/timeout).
-            this.reqlog?.log({
-                kind: "memtree",
-                indexOnly: opts.indexOnly === true,
-                ms: Date.now() - started,
-                ok,
-                status,
-                requestBytes: Buffer.byteLength(payload),
-                // Present only when the request carried a model for server-side
-                // budget resolution — the client-visible half of the server's
-                // "/v1/context_memory budget" log line.
-                ...(opts.model && !opts.indexOnly ? { model: opts.model } : {}),
-                ...diagnostics,
-            });
+            if (!resent)
+                this.reqlog?.log({
+                    kind: "memtree",
+                    indexOnly: opts.indexOnly === true,
+                    ms: Date.now() - started,
+                    ok,
+                    status,
+                    requestBytes: Buffer.byteLength(payload),
+                    ...(planned.limit ? { bodyLimit: planned.limit } : {}),
+                    // 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 }
+                        : !ok && opts.signal?.aborted && callerCut(status) ? { callerAborted: true } : {}),
+                    // Present only when the request carried a model for server-side
+                    // budget resolution — the client-visible half of the server's
+                    // "/v1/context_memory budget" log line.
+                    ...(opts.model && !opts.indexOnly ? { model: opts.model } : {}),
+                    ...diagnostics,
+                });
         }
     }
+    /** One POST of a MemTree call's body. */
+    postContextMemory(payload, opts, signal) {
+        return fetch(`${this.baseUrl}/v1/context_memory`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.apiKey}`,
+                "content-type": "application/json",
+                "x-client": CLIENT_NAME,
+                "x-client-version": CLIENT_VERSION,
+                "x-client-features": CLIENT_FEATURES,
+                ...(opts.sessionId ? { "x-claude-code-session-id": opts.sessionId } : {}),
+                ...(opts.clientMeta && Object.keys(opts.clientMeta).length
+                    ? { "x-client-meta": JSON.stringify(opts.clientMeta) }
+                    : {}),
+                // Compress calls only: an index-only call returns no memory.
+                ...(this.memtreeTools && !opts.indexOnly
+                    ? { "x-memtree-tools": this.memtreeTools }
+                    : {}),
+            },
+            body: payload,
+            signal,
+        });
+    }
+    /**
+     * Whether a failed answer to a call that sent references asks for their bytes: the
+     * server lacks some images (409: those are forgotten), or refuses references (400:
+     * this request's forgotten, or none ever again when the key may not send them).
+     */
+    refusedRefs(status, text, refs) {
+        const missing = status === MISSING_IMAGES_STATUS ? missingImageShas(text) : undefined;
+        const refused = refusesImageRefs(status, text);
+        if (missing !== undefined) {
+            this.imageRefs.forget(missing.length ? missing : refs);
+        }
+        else if (refused === "never") {
+            this.imageRefs.disable();
+        }
+        else if (refused === "this") {
+            this.imageRefs.forget(refs);
+        }
+        else {
+            return false;
+        }
+        this.log(`context_memory ${status} on image references: sending their bytes`);
+        return true;
+    }
+    /**
+     * 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
+     * error carries 413, the status the server's front end would have answered.
+     */
+    oversized(limit, opts) {
+        this.reqlog?.log({
+            kind: "memtree", indexOnly: opts.indexOnly === true, ms: 0, ok: false,
+            requestBytes: limit?.requestBytes ?? 0, ...(limit ? { bodyLimit: limit } : {}),
+        });
+        this.log(`context_memory body of ${limit?.requestBytes ?? "?"} bytes over the limit: not sent`);
+        return Object.assign(new Error("context_memory body over the size limit (not sent)"), { status: 413, bodyLimit: true });
+    }
     log(msg) {
         if (this.debug)
             console.error(`[ccc proxy] ${msg}`);
     }
 }
+/** 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(() => "");
+    signal.throwIfAborted();
+    return text;
+}
 /** 402 bodies are FastAPI JSON: {"detail": "<human-readable payment text>"}. */
 function extract402Detail(bodyText) {
     try {
@@ -1470,4 +1678,26 @@ export function withFinalReply(messages, reply) {
         return messages;
     return [...messages, reply];
 }
+/**
+ * Whether a failed call its caller aborted was cut by that abort: before any answer, or while
+ * a 2xx body was still being read. Any other status is the server's own answer.
+ */
+function callerCut(status) {
+    return status === undefined || (status >= 200 && status < 300);
+}
+/** `baseMs` plus COMPRESS_TIMEOUT_MS_PER_KIB per KiB of `bytes`. */
+function scaledTimeout(baseMs, bytes) {
+    if (!Number.isFinite(baseMs))
+        return baseMs;
+    return baseMs + Math.ceil(Math.max(0, bytes) / 1024) * COMPRESS_TIMEOUT_MS_PER_KIB;
+}
+/**
+ * One conversation for background indexing: its session and its first message after the
+ * system prompt, media left out (Claude Code's media eviction keeps it). Subagents share
+ * the session id but not that message.
+ */
+function indexLaneKey(sessionId, messages) {
+    const first = messages.find((message) => message.role !== "system");
+    return JSON.stringify([sessionId ?? null, first ? mediaFreeMessageHash(first) : ""]);
+}
 //# sourceMappingURL=memtree.js.map