claude-code-infinite 1.0.22 → 1.0.25

package/dist/proxy.js

@@ -40,7 +40,7 @@
  */
 import { capCacheBreakpoints } from "./route-cache.js";
 import { PromptAccounting } from "./prompt-accounting.js";
-import { INDEX_WAIT_RETRY_AFTER_SECONDS, RouteFallbackFailures } from "./route-fallback.js";
+import { INDEX_WAIT_RETRY_AFTER_SECONDS, RouteFallbackFailures, pausedRefusal } from "./route-fallback.js";
 import { createCountTokensSession, CountTokensCooldowns, plausibleSample, } from "./count-tokens.js";
 import { RequestSizing, estimateRequestTokens, fitsMeasured, fitsNative, outputReservation } from "./request-sizing.js";
 import { routeMessageHash, stablePrefixMessageHash } from "./route-identity.js";
@@ -56,7 +56,7 @@ import { COMPRESSED_NOTICE, compressedTotalsText, DEGRADED_NOTICE, NOT_COMPRESSE
 import { NoticeDeliveryQueue, MEMTREE_COMPACT_COMMAND, MEMTREE_HELP_COMMAND, TRAILER_LABEL, LINK_LABEL, linkLines, urlLine, terminalSupportsHyperlinks, isMemtreeViewCommand, sessionCommandArgs, parseNoticeHookInput, } from "./hooks.js";
 import { USAGE_LABEL, USAGE_SIGN_IN_NOTE } from "./usage-link.js";
 import { hyperlink } from "./payment-gate.js";
-import { PaymentNoticeThrottle, paymentNoticeText } from "./payment-notice.js";
+import { PaymentNoticeThrottle, pausedCompactionText, pausedRefusalMessage, paymentNoticeText, subscribeUrlFromDetail } from "./payment-notice.js";
 import { MEMTREE_LINKS_MAX_SESSIONS } from "./memtree-links.js";
 import { describeClaudeCodeRequest, inspectMonitorTranscript, knownSideRequestKind, transcriptWarning, isClaudeCodeSideRequest, memtreeClientMeta, sessionTag, } from "./cc-request.js";
 import { isResumableSessionId } from "./resume-hint.js";
@@ -134,9 +134,9 @@ function checkAwaitedIndex(opts, attempt, shutdownSignal) {
     // Bound both the individual body read and repeated 202 responses. A page
     // that never completes must eventually return the lane to growth backoff.
     const timeoutMs = Math.max(1, Math.min(opts.awaitedIndexProbeTimeoutMs ?? 5_000, waiting.deadline - Date.now()));
-    const signal = AbortSignal.any([shutdownSignal, AbortSignal.timeout(timeoutMs)]);
+    const probe = abortOnTimeoutOrShutdown(timeoutMs, shutdownSignal);
     opts.memtree
-        .fetchMemTree(`/usage/memtree/${waiting.pageId}.json`, "application/json", signal)
+        .fetchMemTree(`/usage/memtree/${waiting.pageId}.json`, "application/json", probe.signal)
         .then((page) => {
         if (page.status === 202 && Date.now() < waiting.deadline)
             return;
@@ -151,9 +151,32 @@ function checkAwaitedIndex(opts, attempt, shutdownSignal) {
             attempt.awaitingIndex = undefined;
     })
         .finally(() => {
+        probe.dispose();
         waiting.checking = false;
     });
 }
+/**
+ * A signal that aborts after `timeoutMs` or when `shutdownSignal` aborts.
+ * Not AbortSignal.any([shutdown, AbortSignal.timeout(ms)]): on Node 20 the
+ * composite holds its sources weakly, so a GC can collect the timeout signal
+ * and its abort never fires, leaving a hung probe open for good. Here the
+ * timer and the shutdown listener hold the controller until dispose().
+ */
+function abortOnTimeoutOrShutdown(timeoutMs, shutdownSignal) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    // Unreferenced like AbortSignal.timeout: a probe never holds the process open.
+    const timer = setTimeout(abort, timeoutMs);
+    timer.unref();
+    shutdownSignal.addEventListener("abort", abort, { once: true });
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            clearTimeout(timer);
+            shutdownSignal.removeEventListener("abort", abort);
+        },
+    };
+}
 /**
  * Record lag evidence from `result` (indexLagEvidence): a refusal of this
  * request then waits for the index, and the cached answer expires after the
@@ -280,7 +303,9 @@ export function startProxy(opts) {
     const shutdownAbort = new AbortController();
     const state = {
         paymentNotice: new PaymentNoticeThrottle(opts.paymentNoticeIntervalMs),
+        pausedNearWindowWarned: new Set(),
         unpaidDetail: () => opts.memtree.paymentRequiredDetail,
+        pausedDetail: () => opts.memtree.pausedDetail,
         usageUrl: opts.memtree.usageDashboardUrl,
         sessionStartNotice: opts.sessionStartNotice,
         diagnostics: opts.diagnostics,
@@ -1694,11 +1719,20 @@ async function handleMessages(req, res, opts, upstream, state) {
         capture(opts, "anthropic-request", forwardBody);
         const paymentDetail = opts.memtree.paymentRequiredDetail;
         const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
-        if (mayQueueNotice && paymentDetail !== null && state.paymentNotice.due()) {
-            state.notices.queueSuffix(paymentNoticeText(paymentDetail, recapLink(state, sessionId)?.link), () => {
+        const overBudget = reachedBudget(rec.compaction);
+        if (mayQueueNotice && paymentDetail !== null &&
+            (state.paymentNotice.due() || (overBudget && !nearWindowWarned(state, sessionId)))) {
+            // A paused refusal of this very request withdraws it (refuseWholeRequest),
+            // and any later one withdraws its near-window line.
+            const handle = state.notices.queueSuffix(paymentNoticeText(paymentDetail, recapLink(state, sessionId)?.link, { overBudget }), () => {
                 state.paymentNotice.markShown();
+                if (overBudget && sessionId !== undefined)
+                    addNearWindowWarned(state, sessionId);
                 state.diagnostics?.record("paused_notice", { trigger: "turn" });
             }, noticePromptId);
+            pausedNotices.set(rec, handle);
+            if (overBudget)
+                state.nearWindowNotice = handle;
         }
         else if (mayQueueNotice && paymentDetail === null) {
             state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
@@ -1953,10 +1987,15 @@ function joinNoticeLines(...parts) {
 export const MEMTREE_COMPACT_MIN_TOKENS = 20_000;
 /** The reply to a ccc slash command, or undefined for an ordinary prompt. */
 function sessionCommandReply(state, sessionId, prompt) {
+    const unpaid = state.unpaidDetail();
+    // Paused, compaction needs the MemTree it cannot reach: say how to resume instead.
+    const paused = unpaid === null ? undefined
+        : pausedCompactionText(viewUrl(subscribeUrlFromDetail(unpaid)));
     if (sessionCommandArgs(prompt, MEMTREE_HELP_COMMAND) !== undefined) {
         return [
             "• /memtree-view · show this session's MemTree page link",
-            `• /memtree-compact [tokens | off] · compact this session on your next message (default half the budget, at least ${MEMTREE_COMPACT_MIN_TOKENS / 1000}k)`,
+            paused !== undefined ? `• ${paused}`
+                : `• /memtree-compact [tokens | off] · compact this session on your next message (default half the budget, at least ${MEMTREE_COMPACT_MIN_TOKENS / 1000}k)`,
             usageLines(state),
         ].filter((line) => line !== undefined).join("\n");
     }
@@ -1977,6 +2016,8 @@ function sessionCommandReply(state, sessionId, prompt) {
         state.storedPrefixLookups.set(sessionId, null);
         return `${TRAILER_LABEL} compaction off: the conversation is sent whole, and MemTree compresses only when it outgrows the model's budget.`;
     }
+    if (paused !== undefined)
+        return `${TRAILER_LABEL} ${paused}`;
     if (args === "") {
         // Back to the automatic target (half the budget, or CCC_COMPACT_TARGET).
         // Under CCC_COMPACT_TARGET=off the default is off, so pin the automatic
@@ -2059,7 +2100,9 @@ function viewUrl(url) {
  */
 function sessionLink(state, sessionId, source) {
     const newest = state.newestTrees?.peek(sessionId);
-    const note = source && !source.compressed ? { note: NOT_COMPRESSED_NOTE } : {};
+    // The note suggests /memtree-compact, which cannot run while MemTree is paused.
+    const note = source && !source.compressed && state.unpaidDetail() === null
+        ? { note: NOT_COMPRESSED_NOTE } : {};
     if (newest)
         return { key: newest.key, link: newest.url, ...note };
     return source ? { key: source.index, link: source.url, ...note } : undefined;
@@ -2170,6 +2213,9 @@ function noteMemtreeHealth(state, compression) {
     }
     if (compression.liveHealth === "success") {
         state.toolRecoveryCooldownUntil = 0;
+        // Paid again: a later pause (next month's limit) warns near the window afresh.
+        if (state.unpaidDetail() === null)
+            state.pausedNearWindowWarned.clear();
     }
 }
 /**
@@ -3892,6 +3938,7 @@ async function selectForwardCandidate(args) {
         args.rec.overBudgetForward = { reason: measurement.source === "exact"
                 ? "exact-count-fits-window" : measurement.source === "bytes"
                 ? "bytes-fallback-fits-window" : "estimate-fits-window" };
+        warnPausedNearWindow(args.state, args.rec, requestSessionId(args.req));
     }
     return changed ? candidate.body : intended;
 }
@@ -3911,7 +3958,9 @@ async function wholeRequestRefused(sizing, candidate, limits) {
 }
 /** Write the bounded fallback refusal (route-fallback.ts); always false. */
 function refuseWholeRequest(args, inputTokens, budgetTokens) {
-    const failure = args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
+    const unpaid = args.state.pausedDetail();
+    const failure = unpaid !== null ? pausedRefusal(pausedRefusalMessage(unpaid))
+        : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
     args.state.diagnostics?.record("refusal", {
@@ -3923,14 +3972,89 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         lane: args.routeKey, attempt: failure.attempt, status: failure.status,
         inputTokens, outputTokens: args.body.max_tokens ?? 0,
         outputReservation: bodyOutputReservation(args.body), indexBehind: args.rec.indexBehind === true,
-        budgetTokens, modelContextLimit: args.modelContextLimit,
+        budgetTokens, modelContextLimit: args.modelContextLimit, ...(unpaid !== null ? { paused: true } : {}),
     };
+    if (unpaid !== null)
+        cancelPausedNotice(args.state, args.rec);
     if (args.res.headersSent || args.res.destroyed)
         return false;
     args.res.writeHead(failure.status, { "content-type": "application/json", ...failure.headers });
     args.res.end(JSON.stringify(failure.body));
+    if (unpaid !== null) {
+        notePausedRefusal(args.state, args.rec, args.routeKey, requestSessionId(args.req));
+    }
     return false;
 }
+/**
+ * The refusal text already says MemTree is paused and how to resume, so it
+ * counts as the paused notice: the throttle restarts, and this request's
+ * queued notice is withdrawn rather than shown a second time after it.
+ */
+function notePausedRefusal(state, rec, lane, sessionId) {
+    // A subagent's or hidden away-summary's refusal is not on the user's screen.
+    if (rec.routeLane === "main") {
+        state.paymentNotice.markShown();
+        // Past the window /compact no longer fits: withdraw an undelivered
+        // near-window line and show none later.
+        state.notices.cancel(state.nearWindowNotice);
+        if (sessionId !== undefined)
+            addNearWindowWarned(state, sessionId);
+    }
+    // A tool turn in the outage cooldown or its lane's growth backoff refuses on
+    // the last 402 without asking. End both so the next request asks MemTree
+    // again (a 402 answers fast) and paying takes effect with no restart. A
+    // concurrent attempt still compressing (no backoff yet) keeps its slot.
+    state.toolRecoveryCooldownUntil = 0;
+    const attempt = state.toolRecoveryAttemptedLanes.get(lane);
+    if (attempt && (!attempt.inFlight || attempt.retryAtTokens !== undefined)) {
+        state.toolRecoveryAttemptedLanes.delete(lane);
+    }
+}
+/** Withdraw the paused notice this request queued: its refusal says the same. */
+function cancelPausedNotice(state, rec) {
+    state.notices.cancel(pausedNotices.get(rec));
+    pausedNotices.delete(rec);
+}
+/**
+ * A paused main-lane request over the budget, still fitting the window (often a
+ * tool round): once per session, say /compact still works now. A turn that
+ * already queued the paused notice carries the line itself.
+ */
+function warnPausedNearWindow(state, rec, sessionId) {
+    const detail = state.unpaidDetail();
+    // Paid again: a later pause (next month's limit) warns afresh.
+    if (detail === null)
+        state.pausedNearWindowWarned.clear();
+    // Never replace another queued notice (or this one again): a later request tries.
+    if (detail === null || rec.routeLane !== "main" || sessionId === undefined ||
+        pausedNotices.has(rec) || nearWindowWarned(state, sessionId) ||
+        state.notices.hasPending(state.mainPromptId))
+        return;
+    state.nearWindowNotice = state.notices.queueSuffix(paymentNoticeText(detail, undefined, { overBudget: true }), () => {
+        state.paymentNotice.markShown();
+        addNearWindowWarned(state, sessionId);
+        state.diagnostics?.record("paused_notice", { trigger: "turn" });
+    }, state.mainPromptId);
+}
+/** Remember a warned session, keeping the set bounded (oldest first out). */
+function addNearWindowWarned(state, sessionId) {
+    state.pausedNearWindowWarned.delete(sessionId);
+    state.pausedNearWindowWarned.add(sessionId);
+    if (state.pausedNearWindowWarned.size > MEMTREE_LINKS_MAX_SESSIONS) {
+        const oldest = state.pausedNearWindowWarned.values().next().value;
+        if (oldest !== undefined)
+            state.pausedNearWindowWarned.delete(oldest);
+    }
+}
+function nearWindowWarned(state, sessionId) {
+    return sessionId !== undefined && state.pausedNearWindowWarned.has(sessionId);
+}
+/** Whether this turn's own size estimate reached its whole-request budget. */
+function reachedBudget(compaction) {
+    return compaction !== undefined && (compaction.estimatedTokens ?? 0) >= compaction.budgetTokens;
+}
+/** The paused notice a degraded request queued, until it is refused or settles. */
+const pausedNotices = new WeakMap();
 const changedDeliveryRecords = new WeakSet();
 const selectedCandidates = new WeakMap();
 const candidateSizeOwners = new WeakMap();