claude-code-infinite 1.0.27 → 1.0.29

package/dist/proxy.js

@@ -56,12 +56,14 @@ 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 { keyInvalidNoticeText, keyInvalidRefusalMessage } from "./key-status.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";
 import { conservativeBodyTokens } from "./token-estimate.js";
 import { claudeAuthFromHeaders, upstreamErrorCode } from "./claude-auth.js";
+import { rateLimitFromResponse } from "./rate-limit.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
 const DEFAULT_UPSTREAM = "https://api.anthropic.com";
 const HOOK_BODY_LIMIT = 64 * 1024;
@@ -93,23 +95,39 @@ const SKIP_RESPONSE_HEADERS = new Set([
     "transfer-encoding",
 ]);
 /**
- * Budget fallback until the server reports `model_budget_tokens`: this share
- * of the model's context window. 0.8 by default; NEAR_WINDOW_FALLBACK_RATIO
- * (900k of 1M) for the 1M-window models the server budgets at 900k for ccc
- * (NEAR_WINDOW_MODEL_RE). Plain Claude Code 2.1.302 auto-compacts a 1M window
- * at 967k, so MemTree compresses no earlier than ~70k before it would; ccc
- * lifts Claude Code's own 977k refusal (claude-env.ts) so a tool turn that
+ * Budget fallback until the server reports `model_budget_tokens`, mirroring the
+ * server's ccc policy (polychat index_budget.py): every Claude model compresses
+ * near its window, NEAR_WINDOW_FALLBACK_RATIO of it but no later than Claude
+ * Code's own auto-compact point (window - CLAUDE_CODE_AUTOCOMPACT_RESERVE_TOKENS)
+ * and never below FALLBACK_BUDGET_WINDOW_RATIO: 900k of 1M, 167k of 200k; at
+ * most a Sonnet's usable-context ceiling (SONNET_CEILINGS). Other models get
+ * FALLBACK_BUDGET_WINDOW_RATIO. Plain Claude Code 2.1.302 auto-compacts a 1M
+ * window at 967k, so MemTree compresses no earlier than ~70k before it would;
+ * ccc lifts Claude Code's own 977k refusal (claude-env.ts) so a tool turn that
  * jumps past the budget reaches the proxy and is compressed here.
  */
 export const FALLBACK_BUDGET_WINDOW_RATIO = 0.8;
 export const NEAR_WINDOW_FALLBACK_RATIO = 0.9;
-/** Opus 5.5, Opus 5, Opus 4.8 and Fable 5 / 5.1 (polychat LARGE_CONTEXT_MODELS). */
-const NEAR_WINDOW_MODEL_RE = /claude-(?:opus-(?:4-8|5-5|5)|fable-5(?:-1)?)(?![0-9])/i;
-const ONE_MILLION_TOKENS = 1_000_000;
-/** The fallback share of the window for `model` (see FALLBACK_BUDGET_WINDOW_RATIO). */
-export function fallbackBudgetRatio(model, modelContextLimit) {
-    return typeof model === "string" && modelContextLimit >= ONE_MILLION_TOKENS &&
-        NEAR_WINDOW_MODEL_RE.test(model) ? NEAR_WINDOW_FALLBACK_RATIO : FALLBACK_BUDGET_WINDOW_RATIO;
+/** Claude Code 2.1.302 auto-compacts at window - min(max_tokens, 20k) - 13k. */
+const CLAUDE_CODE_AUTOCOMPACT_RESERVE_TOKENS = 33_000;
+/** The ids the server resolves to a Claude model (polychat ANTHROPIC_MODEL_FAMILIES). */
+const CLAUDE_FAMILY_RE = /opus|sonnet|haiku|fable|mythos/i;
+/**
+ * polychat USABLE_CONTEXT_CEILING_TOKENS_BY_MODEL: the Sonnets degrade well
+ * before their window. Sonnet 5 / 5.5 550k; every other Sonnet 400k. First match wins.
+ */
+const SONNET_CEILINGS = [
+    [/sonnet-5(?![0-9])/i, 550_000],
+    [/sonnet/i, 400_000],
+];
+/** The fallback whole-request budget for `model` on this window (see above). */
+export function fallbackBudgetTokens(model, modelContextLimit) {
+    if (typeof model !== "string" || !CLAUDE_FAMILY_RE.test(model)) {
+        return Math.floor(modelContextLimit * FALLBACK_BUDGET_WINDOW_RATIO);
+    }
+    const nearWindow = Math.max(Math.floor(modelContextLimit * FALLBACK_BUDGET_WINDOW_RATIO), Math.min(Math.floor(modelContextLimit * NEAR_WINDOW_FALLBACK_RATIO), modelContextLimit - CLAUDE_CODE_AUTOCOMPACT_RESERVE_TOKENS));
+    const ceiling = SONNET_CEILINGS.find(([re]) => re.test(model))?.[1];
+    return ceiling === undefined ? nearWindow : Math.min(nearWindow, ceiling);
 }
 /**
  * An explicit target is capped at this share of the budget: a compaction to
@@ -304,11 +322,16 @@ export function startProxy(opts) {
     const shutdownAbort = new AbortController();
     const state = {
         paymentNotice: new PaymentNoticeThrottle(opts.paymentNoticeIntervalMs),
+        keyNotice: new PaymentNoticeThrottle(opts.paymentNoticeIntervalMs),
+        keyInvalid: () => opts.memtree.keyInvalid,
+        keyPageUrl: opts.memtree.keyPageUrl,
         pausedNearWindowWarned: new Set(),
         unpaidDetail: () => opts.memtree.paymentRequiredDetail,
         pausedDetail: () => opts.memtree.pausedDetail,
         usageUrl: opts.memtree.usageDashboardUrl,
         sessionStartNotice: opts.sessionStartNotice,
+        promptSubmitNotice: opts.promptSubmitNotice,
+        projectTrees: opts.projectTrees,
         diagnostics: opts.diagnostics,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
@@ -726,17 +749,20 @@ onMainStop) {
             recordSessionStart(state, parsed.source);
             noteMainSessionStart(state, parsed.source, parsed.session_id);
         }
+        // Earlier trees in this project: asked now, so its wait overlaps the resume's.
+        const contextPromise = projectTreesContext(state.projectTrees, parsed);
         // A resume waits briefly for the newest tree; a fresh session has none to wait for.
         if (parsed.agent_id === undefined && parsed.source === "resume") {
             await state.newestTrees?.settle(parsed.session_id);
         }
         const line = joinNoticeLines(resumeLinkLine(state, parsed), resumePaymentNotice(state, parsed), extraSessionStartLine(state.sessionStartNotice, parsed));
-        if (!line) {
+        const context = await contextPromise;
+        if (!line && !context) {
             res.writeHead(204);
             res.end();
             return;
         }
-        const body = Buffer.from(JSON.stringify({ systemMessage: line }), "utf-8");
+        const body = Buffer.from(JSON.stringify(sessionStartOutput(line, context)), "utf-8");
         res.writeHead(200, {
             "content-type": "application/json",
             "content-length": String(body.length),
@@ -782,6 +808,17 @@ onMainStop) {
             state.promptAccounting.add(parsed.session_id, parsed.prompt_id, parsed.prompt);
             recordMainPromptNotice(state, parsed.prompt_id, parsed.prompt);
         }
+        const line = parsed.agent_id === undefined ? promptSubmitLine(state) : undefined;
+        if (line) {
+            const body = Buffer.from(JSON.stringify({ systemMessage: line }), "utf-8");
+            res.writeHead(200, {
+                "content-type": "application/json",
+                "content-length": String(body.length),
+                "cache-control": "no-store",
+            });
+            res.end(body);
+            return;
+        }
         res.writeHead(204);
         res.end();
         return;
@@ -1697,6 +1734,13 @@ async function handleMessages(req, res, opts, upstream, state) {
     // it pending for the next turn.
     if (result && sessionId !== undefined)
         state.compactNow.delete(sessionId);
+    // A first 402 starts fetching the short checkout link (memtree.ts): give the
+    // paused notice below a moment to show it instead of the long one. Only a turn
+    // that can show the notice waits, and only while that fetch is in flight.
+    if (!result && displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration &&
+        state.paymentNotice.due() && opts.memtree.paymentRequiredDetail !== null) {
+        await opts.memtree.paymentLinkSettled?.(PAYMENT_LINK_NOTICE_WAIT_MS);
+    }
     if (downstreamClosedDuringCompression ||
         (res.destroyed && !res.writableFinished)) {
         releaseUncommittedRouteDecision();
@@ -1724,7 +1768,15 @@ async function handleMessages(req, res, opts, upstream, state) {
         const paymentDetail = opts.memtree.paymentRequiredDetail;
         const mayQueueNotice = displayForThisTurn && state.mainPromptGeneration === noticePromptGeneration;
         const overBudget = reachedBudget(rec.compaction);
-        if (mayQueueNotice && paymentDetail !== null &&
+        if (state.keyInvalid()) {
+            // A refused key (401/403) says why MemTree is off and how to fix it;
+            // throttled like the payment notice, and quiet in between.
+            if (mayQueueNotice && state.keyNotice.due()) {
+                // A refusal of this very request says the same and withdraws it.
+                pausedNotices.set(rec, state.notices.queueSuffix(keyInvalidNoticeText(state.keyPageUrl), () => state.keyNotice.markShown(), noticePromptId));
+            }
+        }
+        else 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.
@@ -1739,7 +1791,24 @@ async function handleMessages(req, res, opts, upstream, state) {
                 state.nearWindowNotice = handle;
         }
         else if (mayQueueNotice && paymentDetail === null) {
-            state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
+            // Under the budget the whole request is what compression would have
+            // sent: the turn is not degraded, so the failure stays in the logs.
+            const warn = () => {
+                state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
+                rec.degradedNotice = "shown";
+            };
+            if (compressionNeeded(rec.compaction)) {
+                warn();
+            }
+            else {
+                // Delivery sizes the request again (an exact count, else a
+                // conservative bound): a turn it finds over the budget warns then.
+                rec.degradedNotice = "quiet-under-budget";
+                quietDegrades.set(rec, () => {
+                    if (state.mainPromptGeneration === noticePromptGeneration)
+                        warn();
+                });
+            }
         }
         return logged(forwardRaw(req, res, forwardBody, opts, upstream, state.shutdownSignal, rec).then((delivered) => {
             noteWholeSize();
@@ -1973,6 +2042,15 @@ function resumePaymentNotice(state, input) {
     state.diagnostics?.record("paused_notice", { trigger: "resume" });
     return state.notices.warningText(paymentNoticeText(detail));
 }
+/** ProxyOptions.promptSubmitNotice's line for this prompt; never throws. */
+function promptSubmitLine(state) {
+    try {
+        return state.promptSubmitNotice?.();
+    }
+    catch {
+        return undefined;
+    }
+}
 /** The caller's extra SessionStart line; a throwing provider shows nothing. */
 function extraSessionStartLine(provider, input) {
     if (!provider || input.agent_id !== undefined || input.source === "compact")
@@ -1984,11 +2062,39 @@ function extraSessionStartLine(provider, input) {
         return undefined;
     }
 }
+/**
+ * Earlier sessions in this project (project-trees.ts) for a main session's
+ * start: fresh, resumed, cleared or forked, never a compaction. Never throws.
+ */
+async function projectTreesContext(hint, input) {
+    if (!hint || input.agent_id !== undefined || input.source === "compact")
+        return undefined;
+    try {
+        return await hint.contextFor(input.session_id);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The SessionStart hook's answer: the banner line for the user
+ * (`systemMessage`), model context (`additionalContext`), or both.
+ */
+export function sessionStartOutput(line, context) {
+    return {
+        ...(line ? { systemMessage: line } : {}),
+        ...(context
+            ? { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: context } }
+            : {}),
+    };
+}
 function joinNoticeLines(...parts) {
     const present = parts.filter((part) => !!part);
     return present.length ? present.join("\n") : undefined;
 }
 export const MEMTREE_COMPACT_MIN_TOKENS = 20_000;
+/** How long a paused turn waits for the short checkout link before its notice (once). */
+export const PAYMENT_LINK_NOTICE_WAIT_MS = 1_000;
 /** The reply to a ccc slash command, or undefined for an ordinary prompt. */
 function sessionCommandReply(state, sessionId, prompt) {
     const unpaid = state.unpaidDetail();
@@ -2500,8 +2606,8 @@ function serverBudgetKey(model, modelContextLimit) {
 /**
  * The session's whole-request budget: CCC_BUDGET_TOKENS when set (tests),
  * else the model budget the server last reported for this model and window,
- * else the window times fallbackBudgetRatio (servers that predate
- * `model_budget_tokens`, and the first request before any response).
+ * else fallbackBudgetTokens (servers that predate `model_budget_tokens`, and
+ * the first request before any response).
  */
 function resolveBudget(opts, state, model, modelContextLimit) {
     if (opts.budgetTokensOverride !== undefined) {
@@ -2511,7 +2617,7 @@ function resolveBudget(opts, state, model, modelContextLimit) {
     if (reported !== undefined)
         return { tokens: reported, source: "server" };
     return {
-        tokens: Math.floor(modelContextLimit * fallbackBudgetRatio(model, modelContextLimit)),
+        tokens: fallbackBudgetTokens(model, modelContextLimit),
         source: "window-ratio",
     };
 }
@@ -3554,7 +3660,9 @@ async function recoverToolRouteMiss(args) {
         // a later turn. An unpaid key (402, possibly set by this very compress)
         // or a shutting-down proxy gets no retry.
         if (!state.shutdownSignal.aborted &&
-            opts.memtree.paymentRequiredDetail === null) {
+            opts.memtree.paymentRequiredDetail === null &&
+            !opts.memtree.keyInvalid // a refused key refuses the index too
+        ) {
             opts.memtree.indexInBackground(hash, msgsForMemtree, modelContextLimit, requestSessionId(req), args.clientMeta, transcriptTimesFor(opts, requestSessionId(req), agentAttributionId(req)));
         }
         return forwardOriginal();
@@ -3918,6 +4026,8 @@ async function selectForwardCandidate(args) {
             target = policy.sizing.register(replacement, "replacement");
     }
     const selection = await policy.sizing.select(target, args.limits);
+    const quietDegrade = quietDegrades.get(args.rec);
+    quietDegrades.delete(args.rec);
     if (!selection) {
         if (args.rec.lateCountRecovery)
             args.rec.lateCountRecovery.outcome = "refused";
@@ -3943,6 +4053,7 @@ async function selectForwardCandidate(args) {
                 ? "exact-count-fits-window" : measurement.source === "bytes"
                 ? "bytes-fallback-fits-window" : "estimate-fits-window" };
         warnPausedNearWindow(args.state, args.rec, requestSessionId(args.req));
+        quietDegrade?.();
     }
     return changed ? candidate.body : intended;
 }
@@ -3962,9 +4073,12 @@ async function wholeRequestRefused(sizing, candidate, limits) {
 }
 /** Write the bounded fallback refusal (route-fallback.ts); always false. */
 function refuseWholeRequest(args, inputTokens, budgetTokens) {
-    const unpaid = args.state.pausedDetail();
-    const failure = unpaid !== null ? pausedRefusal(pausedRefusalMessage(unpaid))
-        : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
+    // A refused key or a paused one: a retry cannot fix either, so it is final at once.
+    const keyInvalid = args.state.keyInvalid();
+    const unpaid = keyInvalid ? null : args.state.pausedDetail();
+    const failure = keyInvalid ? pausedRefusal(keyInvalidRefusalMessage(args.state.keyPageUrl))
+        : 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", {
@@ -3977,8 +4091,9 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         inputTokens, outputTokens: args.body.max_tokens ?? 0,
         outputReservation: bodyOutputReservation(args.body), indexBehind: args.rec.indexBehind === true,
         budgetTokens, modelContextLimit: args.modelContextLimit, ...(unpaid !== null ? { paused: true } : {}),
+        ...(keyInvalid ? { keyInvalid: true } : {}),
     };
-    if (unpaid !== null)
+    if (unpaid !== null || keyInvalid)
         cancelPausedNotice(args.state, args.rec);
     if (args.res.headersSent || args.res.destroyed)
         return false;
@@ -3987,6 +4102,9 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
     if (unpaid !== null) {
         notePausedRefusal(args.state, args.rec, args.routeKey, requestSessionId(args.req));
     }
+    // The refusal named the key: it counts as the key notice on the user's screen.
+    if (keyInvalid && args.rec.routeLane === "main")
+        args.state.keyNotice.markShown();
     return false;
 }
 /**
@@ -4025,6 +4143,8 @@ function cancelPausedNotice(state, rec) {
  * already queued the paused notice carries the line itself.
  */
 function warnPausedNearWindow(state, rec, sessionId) {
+    if (state.keyInvalid())
+        return; // a refused key, not a pause: the key notice says why
     const detail = state.unpaidDetail();
     // Paid again: a later pause (next month's limit) warns afresh.
     if (detail === null)
@@ -4057,6 +4177,25 @@ function nearWindowWarned(state, sessionId) {
 function reachedBudget(compaction) {
     return compaction !== undefined && (compaction.estimatedTokens ?? 0) >= compaction.budgetTokens;
 }
+/**
+ * Whether the planned size says a turn needed MemTree to compress it: a
+ * forced compaction (budget, window, `/memtree-compact`, a rebuilt prefix), a
+ * size at or over the budget, or a size nobody measured. A planned fit is
+ * provisional: delivery's own sizing can still find the turn over the budget
+ * (quietDegrades), since a plan can undercount.
+ */
+function compressionNeeded(compaction) {
+    if (compaction === undefined || compaction.reason !== undefined)
+        return true;
+    if (compaction.estimatedTokens === undefined)
+        return true;
+    return compaction.estimatedTokens >= compaction.budgetTokens;
+}
+/**
+ * A degraded turn whose plan fit the budget, so it queued no notice: the
+ * notice to queue if delivery's sizing finds it over the budget after all.
+ */
+const quietDegrades = new WeakMap();
 /** The paused notice a degraded request queued, until it is refused or settles. */
 const pausedNotices = new WeakMap();
 const changedDeliveryRecords = new WeakSet();
@@ -4267,6 +4406,9 @@ function forwardAccepted(req, res, bodyBuffer, opts, upstream, shutdownSignal, r
             };
             if (rec) {
                 rec.upstreamStatus = upstreamRes.statusCode ?? 502;
+                const rateLimit = rateLimitFromResponse(rec.upstreamStatus, upstreamRes.headers);
+                if (rateLimit)
+                    rec.rateLimit = rateLimit;
             }
             successfulStatus =
                 typeof upstreamRes.statusCode === "number" &&