claude-code-infinite 1.0.21 → 1.0.22

package/dist/proxy.js

@@ -59,6 +59,7 @@ import { hyperlink } from "./payment-gate.js";
 import { PaymentNoticeThrottle, paymentNoticeText } 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 { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
 const DEFAULT_UPSTREAM = "https://api.anthropic.com";
@@ -92,10 +93,23 @@ const SKIP_RESPONSE_HEADERS = new Set([
 ]);
 /**
  * Budget fallback until the server reports `model_budget_tokens`: this share
- * of the model's context window (800k of Opus 5.5's 1M, matching the server's
- * large-context threshold).
+ * 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
+ * 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;
+}
 /**
  * An explicit target is capped at this share of the budget: a compaction to
  * the budget itself would be over budget again on the next turn and
@@ -269,6 +283,7 @@ export function startProxy(opts) {
         unpaidDetail: () => opts.memtree.paymentRequiredDetail,
         usageUrl: opts.memtree.usageDashboardUrl,
         sessionStartNotice: opts.sessionStartNotice,
+        diagnostics: opts.diagnostics,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
@@ -305,6 +320,7 @@ export function startProxy(opts) {
         laneSizes: new Map(),
     };
     installMemtreeLink(state, state.memtreeLinkPlacement);
+    state.notices.setFirstTreeIntro(opts.firstTreeIntro ?? null);
     const server = http.createServer((req, res) => {
         const accepted = { req, res };
         acceptedRequests.add(accepted);
@@ -387,6 +403,7 @@ export function startProxy(opts) {
                     void beginClose();
                 },
                 drain,
+                mainSessionId: () => state.resumableMainSession,
             });
         });
     });
@@ -617,6 +634,30 @@ export function memtreePageId(pageUrl) {
         return undefined;
     }
 }
+const SESSION_START_SOURCES = new Set(["startup", "resume", "clear", "compact"]);
+/** A main-agent SessionStart, for diagnostics; never fails the hook. */
+function recordSessionStart(state, source) {
+    try {
+        const known = source !== undefined && SESSION_START_SOURCES.has(source);
+        state.diagnostics?.record("session_start", { source: known ? source : "other" });
+    }
+    catch {
+        // Diagnostics are best effort.
+    }
+}
+/**
+ * A resumed or forked session can be resumed again at once; a fresh or
+ * cleared one has nothing to resume until its first turn. Compaction keeps
+ * the same session.
+ */
+function noteMainSessionStart(state, source, sessionId) {
+    if (source === "resume" || source === "fork") {
+        state.resumableMainSession = isResumableSessionId(sessionId) ? sessionId : undefined;
+    }
+    else if (source === "startup" || source === "clear") {
+        state.resumableMainSession = undefined;
+    }
+}
 /** Serve only validated Claude hook POSTs on the randomized localhost path. */
 async function handleNoticeHook(req, res, state, reqlog, 
 /** A main-lane turn ended: the session may be over (its final index). */
@@ -655,6 +696,10 @@ onMainStop) {
         return;
     }
     if (parsed.hook_event_name === "SessionStart") {
+        if (parsed.agent_id === undefined) {
+            recordSessionStart(state, parsed.source);
+            noteMainSessionStart(state, parsed.source, parsed.session_id);
+        }
         // 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);
@@ -1055,6 +1100,8 @@ async function handleMessages(req, res, opts, upstream, state) {
     // reply the session ends with (scheduleFinalIndex, on Stop).
     const mainSessionId = isMainRequest ? requestSessionId(req) : undefined;
     if (mainSessionId !== undefined) {
+        if (isResumableSessionId(mainSessionId))
+            state.resumableMainSession = mainSessionId;
         opts.memtree.noteMainConversation(mainSessionId, {
             messages: msgsForMemtree,
             modelContextLimit,
@@ -1648,7 +1695,10 @@ async function handleMessages(req, res, opts, upstream, state) {
         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), () => state.paymentNotice.markShown(), noticePromptId);
+            state.notices.queueSuffix(paymentNoticeText(paymentDetail, recapLink(state, sessionId)?.link), () => {
+                state.paymentNotice.markShown();
+                state.diagnostics?.record("paused_notice", { trigger: "turn" });
+            }, noticePromptId);
         }
         else if (mayQueueNotice && paymentDetail === null) {
             state.notices.queueSuffix(DEGRADED_NOTICE, undefined, noticePromptId);
@@ -1882,6 +1932,7 @@ function resumePaymentNotice(state, input) {
     if (detail === null)
         return undefined;
     state.paymentNotice.markShown();
+    state.diagnostics?.record("paused_notice", { trigger: "resume" });
     return state.notices.warningText(paymentNoticeText(detail));
 }
 /** The caller's extra SessionStart line; a throwing provider shows nothing. */
@@ -2399,7 +2450,7 @@ 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 FALLBACK_BUDGET_WINDOW_RATIO (servers that predate
+ * else the window times fallbackBudgetRatio (servers that predate
  * `model_budget_tokens`, and the first request before any response).
  */
 function resolveBudget(opts, state, model, modelContextLimit) {
@@ -2410,7 +2461,7 @@ function resolveBudget(opts, state, model, modelContextLimit) {
     if (reported !== undefined)
         return { tokens: reported, source: "server" };
     return {
-        tokens: Math.floor(modelContextLimit * FALLBACK_BUDGET_WINDOW_RATIO),
+        tokens: Math.floor(modelContextLimit * fallbackBudgetRatio(model, modelContextLimit)),
         source: "window-ratio",
     };
 }
@@ -3863,12 +3914,17 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
     const failure = args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
-    console.error("[ccc proxy] request exceeds native context window; recovery failed", {
+    args.state.diagnostics?.record("refusal", {
+        status: failure.status, attempt: failure.attempt,
+        input_ktokens: Math.round(inputTokens / 1000), budget_ktokens: Math.round(budgetTokens / 1000),
+    });
+    // To requests.jsonl, never the console: Claude Code's TUI shows stderr inline.
+    args.rec.refusal = {
         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,
-    });
+    };
     if (args.res.headersSent || args.res.destroyed)
         return false;
     args.res.writeHead(failure.status, { "content-type": "application/json", ...failure.headers });