claude-code-infinite 1.0.20 → 1.0.21

package/dist/proxy.d.ts

@@ -47,7 +47,7 @@ import type { StablePrefixStore } from "./prefix-store.js";
 import type { NewestTreeLookup } from "./memtree-newest.js";
 import type { TranscriptUsageSource } from "./transcript-usage.js";
 import type { ProjectMeta } from "./project-meta.js";
-import { type RequestLogSink } from "./reqlog.js";
+import { type MessagesRecord, type RequestLogSink } from "./reqlog.js";
 export interface ProxyOptions {
     memtree: MemtreeClient;
     /**
@@ -171,6 +171,12 @@ export interface ProxyOptions {
      * user can find sessions by project. Omitted means none is sent.
      */
     projectMeta?: ProjectMeta;
+    /**
+     * An extra line for a main session's SessionStart (not compaction), e.g.
+     * the auto-update result (auto-update.ts). Called on every such hook; the
+     * provider decides how often it has something to say.
+     */
+    sessionStartNotice?: () => string | undefined;
     /** Test-only: forward to this origin instead of api.anthropic.com. */
     upstreamOrigin?: string;
     /** Test-only: dump each forwarded /v1/messages body to this directory. */
@@ -212,7 +218,17 @@ export declare const SUBAGENT_VIEW_NOTE = "(main session's page; subagent pages
 export declare const SUBAGENT_COMPACT_REPLY = "MemTree compact applies to the main session only.";
 /** "50k", "50000", "1.5m" → tokens; undefined when not a positive count. */
 export declare function parseTokenCount(text: string): number | undefined;
+/**
+ * Whether a forwarded compressed body still overflows the window: its exact
+ * count (`exactTokens`, made for delivery), else its reported input tokens,
+ * both Anthropic's own count, so the output floor applies; else its
+ * conservative image-aware bound (token-estimate.ts) with full max_tokens,
+ * never bytes/4, which reads base64 images as text.
+ */
+declare function compressedResultExceedsWindow(body: Record<string, any>, rec: MessagesRecord, compressedRaw: Buffer, modelContextLimit: number, exactTokens?: number): boolean;
 /** Test seam. */
 export declare const __testCapCacheBreakpoints: typeof capCacheBreakpoints;
 export declare const __testEstimateRequestTokens: typeof estimateRequestTokens;
+export declare const __testCompressedResultExceedsWindow: typeof compressedResultExceedsWindow;
+export {};
 //# sourceMappingURL=proxy.d.ts.map

package/dist/proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"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"}

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 { conservativeBodyTokens } from "./token-estimate.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
 const DEFAULT_UPSTREAM = "https://api.anthropic.com";
 const HOOK_BODY_LIMIT = 64 * 1024;
@@ -267,6 +268,7 @@ export function startProxy(opts) {
         paymentNotice: new PaymentNoticeThrottle(opts.paymentNoticeIntervalMs),
         unpaidDetail: () => opts.memtree.paymentRequiredDetail,
         usageUrl: opts.memtree.usageDashboardUrl,
+        sessionStartNotice: opts.sessionStartNotice,
         notices: new NoticeDeliveryQueue(),
         mainNoticePending: false,
         mainPromptGeneration: 0,
@@ -657,7 +659,7 @@ onMainStop) {
         if (parsed.agent_id === undefined && parsed.source === "resume") {
             await state.newestTrees?.settle(parsed.session_id);
         }
-        const line = joinNoticeLines(resumeLinkLine(state, parsed), resumePaymentNotice(state, parsed));
+        const line = joinNoticeLines(resumeLinkLine(state, parsed), resumePaymentNotice(state, parsed), extraSessionStartLine(state.sessionStartNotice, parsed));
         if (!line) {
             res.writeHead(204);
             res.end();
@@ -950,10 +952,11 @@ async function handleMessages(req, res, opts, upstream, state) {
         upstream, headers: forwardableRequestHeaders(req), requestUrl: req.url,
         signal: state.shutdownSignal,
         onAttempt: (result) => {
-            (rec.countTokens ??= []).push({ statusClass: result.outcome, ms: result.ms });
+            (rec.countTokens ??= []).push({ statusClass: result.outcome, ms: result.ms,
+                bytes: result.bytes ?? 0, timeoutMs: result.timeoutMs ?? 0 });
         },
     }, state.countTokensCooldowns);
-    const requestSizing = new RequestSizing(countSession, opts.countTokens === true);
+    const requestSizing = new RequestSizing(countSession, opts.countTokens === true, typeof body.model === "string" ? body.model : undefined);
     if (carriesServerTools(body))
         serverToolRecords.add(rec);
     const sizeSlot = wholeRequestSizeSlot(state, isMainRequest, requestSessionKey, requestSizeKey, body.model);
@@ -1170,7 +1173,7 @@ async function handleMessages(req, res, opts, upstream, state) {
             // prefix, else whole) with no compress call; at it, compress once to
             // the target (planToolCompaction). A "replay" is a client retry of the
             // request that installed the route, forwarded verbatim.
-            const plan = planToolCompaction({
+            const plan = await planToolCompaction({
                 opts,
                 state,
                 body,
@@ -1207,11 +1210,15 @@ async function handleMessages(req, res, opts, upstream, state) {
                     // A concurrent request of this lane is already compressing.
                     rec.routeRecovery = { outcome: "in-flight" };
                 }
-                else if (prior?.awaitingIndex && !plan.overWindow) {
+                else if (prior?.awaitingIndex && (!plan.overWindow || plan.uncountedOverWindowOnly)) {
                     // The last attempt found no tree for this conversation, so a
                     // compress call could only pass everything through again. Forward
                     // now; the page check lets the next tool turn try once it exists.
+                    // Over the window only by its uncounted bound, delivery may still
+                    // count it; if it refuses, that is an index wait, not a strike.
                     rec.routeRecovery = { outcome: "awaiting-index" };
+                    if (plan.uncountedOverWindowOnly)
+                        rec.indexBehind = true;
                     checkAwaitedIndex(opts, prior, state.shutdownSignal);
                 }
                 else if (prior?.retryAtTokens !== undefined &&
@@ -1350,7 +1357,7 @@ async function handleMessages(req, res, opts, upstream, state) {
     // Stable-prefix (edge) compaction: the main thread's human turns only. The
     // recap rides the main route above; subagents keep per-turn compression.
     const edge = isMainRequest && sessionId !== undefined
-        ? planEdgeCompaction({
+        ? await planEdgeCompaction({
             sizing: requestSizing,
             opts,
             state,
@@ -1877,6 +1884,17 @@ function resumePaymentNotice(state, input) {
     state.paymentNotice.markShown();
     return state.notices.warningText(paymentNoticeText(detail));
 }
+/** The caller's extra SessionStart line; a throwing provider shows nothing. */
+function extraSessionStartLine(provider, input) {
+    if (!provider || input.agent_id !== undefined || input.source === "compact")
+        return undefined;
+    try {
+        return provider();
+    }
+    catch {
+        return undefined;
+    }
+}
 function joinNoticeLines(...parts) {
     const present = parts.filter((part) => !!part);
     return present.length ? present.join("\n") : undefined;
@@ -2442,10 +2460,11 @@ function laneCompaction(opts, state, sessionId, model, modelContextLimit) {
 }
 /** Calibrated input must leave room for the requested output as well. */
 function calibratedSizeExceedsWindow(record, body, modelContextLimit) {
-    // A planning estimate, so the full max_tokens (the floor needs an exact count).
-    const outputTokens = bodyOutputReservation(body, false);
-    return record.sizeSource === "reported" &&
-        (record.estimatedTokens ?? 0) + outputTokens > modelContextLimit;
+    // An exact count reserves the model's output floor, as delivery does; an
+    // estimate reserves the full max_tokens.
+    const outputTokens = bodyOutputReservation(body, exactSizedRecords.has(record));
+    return record.uncountedOverWindow === true || (record.sizeSource === "reported" &&
+        (record.estimatedTokens ?? 0) + outputTokens > modelContextLimit);
 }
 function calibratedSizeExceedsLimits(record, body, modelContextLimit) {
     return (record.sizeSource === "reported" &&
@@ -2515,16 +2534,24 @@ function usedServerTools(rec) {
  * is dropped and the previous sample kept.
  */
 function reportedSample(rec, bytes) {
-    if (changedDeliveryRecords.has(rec))
-        return undefined;
-    if (serverToolRecords.has(rec) || usedServerTools(rec))
-        return undefined;
-    const tokens = reportedInputTokens(rec);
+    const tokens = reportedBodyTokens(rec);
     if (tokens === undefined)
         return undefined;
     const sample = { tokens, forwardedBytes: bytes };
     return plausibleSample(sample) ? sample : undefined;
 }
+/**
+ * Anthropic's input tokens for the body this request forwarded, when its usage
+ * describes that body (not a changed delivery, no server tools). Not filtered
+ * by plausibility: a body that is mostly images is truly cheap per byte.
+ */
+function reportedBodyTokens(rec) {
+    if (changedDeliveryRecords.has(rec))
+        return undefined;
+    if (serverToolRecords.has(rec) || usedServerTools(rec))
+        return undefined;
+    return reportedInputTokens(rec);
+}
 /**
  * Key of a non-main request's size sample (ProxyState.laneSizes): its lane,
  * its own agent id (helpers that carry only a parent id stay apart from the
@@ -2592,7 +2619,7 @@ function boundedSet(map, key, value, limit = STABLE_PREFIX_MAX_SESSIONS) {
  *
  * Fills rec.compaction with the budget, estimate and reason.
  */
-function planEdgeCompaction(args) {
+async function planEdgeCompaction(args) {
     const { opts, state, body, messages, sessionId, modelContextLimit, forwardBody, rec } = args;
     const mode = compactionMode(opts, state, sessionId);
     const budget = resolveBudget(opts, state, body.model, modelContextLimit);
@@ -2644,12 +2671,16 @@ function planEdgeCompaction(args) {
         }
         const prefixCandidate = args.sizing.register(routed.raw, "ride", prefix.lastSize);
         candidateSizeOwners.set(prefixCandidate, prefix);
+        await countIfOverBound(args.sizing, prefixCandidate, body, modelContextLimit);
         const size = args.sizing.plan(prefixCandidate);
         compaction.estimatedTokens = size.tokens;
         compaction.estimatedBytes = routed.raw.length;
         compaction.sizeSource = size.source;
-        const overWindow = routedBodyExceedsContext(body, routed.raw, modelContextLimit) ||
-            calibratedSizeExceedsWindow(compaction, body, modelContextLimit);
+        noteUncountedBound(compaction, args.sizing, prefixCandidate, body, modelContextLimit);
+        // Request-local sizing (an exact count, a calibrated sample, or the
+        // image-aware bound), not bytes: a flatten that kept images is mostly
+        // base64 that costs a fixed amount per image.
+        const overWindow = calibratedSizeExceedsWindow(compaction, body, modelContextLimit);
         const fallback = overWindow ? undefined : { prefix, routed };
         if (state.compactNow.has(sessionId))
             return forced("manual", fallback);
@@ -2663,10 +2694,13 @@ function planEdgeCompaction(args) {
     }
     if (state.compactNow.has(sessionId))
         return forced("manual");
-    const size = args.sizing.plan(args.sizing.register(forwardBody, "original"));
+    const originalCandidate = args.sizing.register(forwardBody, "original");
+    await countIfOverBound(args.sizing, originalCandidate, body, modelContextLimit);
+    const size = args.sizing.plan(originalCandidate);
     compaction.estimatedTokens = size.tokens;
     compaction.estimatedBytes = forwardBody.length;
     compaction.sizeSource = size.source;
+    noteUncountedBound(compaction, args.sizing, originalCandidate, body, modelContextLimit);
     if (calibratedSizeExceedsLimits(compaction, body, modelContextLimit)) {
         return forced(compaction.prefixMiss ? "prefix-mismatch" : "budget");
     }
@@ -2697,7 +2731,7 @@ function planEdgeCompaction(args) {
  *
  * Fills rec.compaction.
  */
-function planToolCompaction(args) {
+async function planToolCompaction(args) {
     const { opts, state, body, messages, sessionId, modelContextLimit, forwardBody, rec } = args;
     const mode = compactionMode(opts, state, sessionId);
     const budget = resolveBudget(opts, state, body.model, modelContextLimit);
@@ -2714,23 +2748,16 @@ function planToolCompaction(args) {
     const stableLane = args.isMainRequest && sessionId !== undefined;
     const current = stableLane ? state.stablePrefixes.get(sessionId) : undefined;
     let ride = args.ride;
-    let overWindow = false;
     if (!ride && current && !prefixMismatch(body, messages, current, sessionId, stablePrefixMessageHash)) {
         const routed = prefixRoutedBody(body, messages, current);
         if (routed) {
             const prefixCandidate = args.sizing.register(routed.raw, "ride", current.lastSize);
             candidateSizeOwners.set(prefixCandidate, current);
-            if (routedBodyExceedsContext(body, routed.raw, modelContextLimit))
-                overWindow = true;
-            else
-                ride = { raw: routed.raw, turnType: "tool-prefix", sizeHolder: current };
+            // Sized below with the request-local sizing; an over-window ride is not
+            // kept as a fallback.
+            ride = { raw: routed.raw, turnType: "tool-prefix", sizeHolder: current };
         }
     }
-    if (!ride) {
-        const original = args.sizing.register(forwardBody, "original");
-        overWindow ||= args.sizing.plan(original).tokens +
-            bodyOutputReservation(body, args.sizing.isExact(original)) > modelContextLimit;
-    }
     const sample = ride
         ? ride.sizeHolder.lastSize
         : stableLane
@@ -2739,12 +2766,18 @@ function planToolCompaction(args) {
     const candidate = args.sizing.register(ride?.raw ?? forwardBody, ride ? "ride" : "original", sample);
     if (ride)
         candidateSizeOwners.set(candidate, ride.sizeHolder);
+    await countIfOverBound(args.sizing, candidate, body, modelContextLimit);
     const size = args.sizing.plan(candidate);
     compaction.estimatedTokens = size.tokens;
     compaction.estimatedBytes = (ride?.raw ?? forwardBody).length;
     compaction.sizeSource = size.source;
-    overWindow ||= !fitsNative(size.tokens, { budget: budget.tokens, context: modelContextLimit,
+    noteUncountedBound(compaction, args.sizing, candidate, body, modelContextLimit);
+    // Judged after any planning count, so a fitting exact count is not
+    // overridden by the estimate it replaced.
+    let overWindow = !fitsNative(size.tokens, { budget: budget.tokens, context: modelContextLimit,
         output: bodyOutputReservation(body, args.sizing.isExact(candidate)) });
+    const uncountedOnly = !overWindow && compaction.uncountedOverWindow === true;
+    overWindow ||= uncountedOnly;
     if (!args.canCompress) {
         if (overWindow)
             return { kind: "pass", original: true };
@@ -2762,6 +2795,7 @@ function planToolCompaction(args) {
         estimateTokens: size.tokens,
         budgetTokens: budget.tokens,
         overWindow,
+        ...(uncountedOnly ? { uncountedOverWindowOnly: true } : {}),
         ...(ride && !overWindow ? { fallback: ride } : {}),
         ...(stableLane ? { replaces: current ?? null } : {}),
     };
@@ -2806,12 +2840,46 @@ function memoryRoutedToolBody(body, messages, route, routeEpoch, sessionId) {
         return null;
     return Buffer.from(JSON.stringify(routed), "utf-8");
 }
-/** Size the assembled input (including system/tools) and reserve output room. */
-function routedBodyExceedsContext(body, routedBody, modelContextLimit) {
-    const outputTokens = bodyOutputReservation(body, false);
-    // This is the existing local byte estimate, not a tokenizer or a hard cap.
-    // Final forwarding checks can replace this estimate with Count Tokens.
-    return approxTokensFromBytes(routedBody.length) + outputTokens > modelContextLimit;
+/**
+ * Count the candidate a planner is about to judge (ride or original, sampled
+ * or not) when only a count could admit it: no exact count, and its per-model
+ * conservative bound plus max_tokens exceeds the window. Delivery reuses the
+ * result.
+ */
+async function countIfOverBound(sizing, candidate, body, modelContextLimit) {
+    await sizing.countIfOverBound(candidate, { budget: modelContextLimit, context: modelContextLimit, output: bodyOutputReservation(body, false) });
+}
+/** Compaction records whose estimatedTokens is an exact count (noteUncountedBound). */
+const exactSizedRecords = new WeakSet();
+/**
+ * Note an exactly counted candidate (exactSizedRecords), or mark a planned
+ * candidate still without an exact count (counting off, or its
+ * planning count failed: countIfOverBound ran first) whose conservative bound
+ * plus max_tokens exceeds the window: delivery would refuse it uncounted, so
+ * it is over the window for planning and takes the normal gated compression.
+ */
+function noteUncountedBound(record, sizing, candidate, body, modelContextLimit) {
+    if (sizing.isExact(candidate)) {
+        exactSizedRecords.add(record);
+        return;
+    }
+    if (sizing.exceedsRequestLimit(candidate) ||
+        candidate.conservativeTokens + bodyOutputReservation(body, false) > modelContextLimit) {
+        record.uncountedOverWindow = true;
+    }
+}
+/**
+ * Whether a forwarded compressed body still overflows the window: its exact
+ * count (`exactTokens`, made for delivery), else its reported input tokens,
+ * both Anthropic's own count, so the output floor applies; else its
+ * conservative image-aware bound (token-estimate.ts) with full max_tokens,
+ * never bytes/4, which reads base64 images as text.
+ */
+function compressedResultExceedsWindow(body, rec, compressedRaw, modelContextLimit, exactTokens) {
+    const counted = exactTokens ?? reportedBodyTokens(rec);
+    const tokens = counted ??
+        conservativeBodyTokens(compressedRaw, typeof body.model === "string" ? body.model : undefined);
+    return tokens + bodyOutputReservation(body, counted !== undefined) > modelContextLimit;
 }
 /** Output room a native-fit check reserves: the model's floor for an exact
  * count, else (an estimate) the full max_tokens. */
@@ -2998,12 +3066,18 @@ function withFlattenCacheBreakpoint(body, ttl) {
     if (messages.length !== 1)
         return messages;
     const only = messages[0];
-    const text = typeof only.content === "string" ? only.content : undefined;
-    if (text === undefined)
-        return messages;
     const cacheControl = { type: "ephemeral" };
     if (ttl !== undefined)
         cacheControl.ttl = ttl;
+    if (Array.isArray(only.content) && only.content.length > 0) {
+        // A flatten that kept images: the breakpoint goes on its last block.
+        const blocks = only.content.map((block) => ({ ...block }));
+        blocks[blocks.length - 1].cache_control = cacheControl;
+        return [{ ...only, content: blocks }];
+    }
+    const text = typeof only.content === "string" ? only.content : undefined;
+    if (text === undefined)
+        return messages;
     return [{ ...only, content: [{ type: "text", text, cache_control: cacheControl }] }];
 }
 /**
@@ -3147,7 +3221,9 @@ async function runBlockingCompression(args) {
         // whatever the fallback gate would refuse to send uncompressed; a bytes/4
         // guess is not sent, as it would force needless compression.
         ...(args.inputCandidate && args.sizing.clientInputTokens(args.inputCandidate) !== undefined
-            ? { clientInputTokens: args.sizing.clientInputTokens(args.inputCandidate) }
+            ? { clientInputTokens: args.sizing.clientInputTokens(args.inputCandidate),
+                // Only an exact count of these bytes may loosen the server's sizing.
+                clientInputTokensExact: args.sizing.isExact(args.inputCandidate) }
             : {}),
         ...(messageUsage && Object.keys(messageUsage).length ? { messageUsage } : {}),
         ...(messageTimes && Object.keys(messageTimes).length ? { messageTimes } : {}),
@@ -3592,8 +3668,11 @@ async function recoverToolRouteMiss(args) {
     // Nothing to ride next turn, or a result that still does not fit the
     // window (the next turn would reject it and compress again): wait for
     // growth before the lane tries again.
-    if (!sizeHolder || routedBodyExceedsContext(body, compressedRaw, modelContextLimit))
+    const exactTokens = args.sizing.exactTokensFor(compressedRaw);
+    if (!sizeHolder ||
+        compressedResultExceedsWindow(body, rec, compressedRaw, modelContextLimit, exactTokens)) {
         backOff();
+    }
     // A reservation that lost its race (stale) or never reached
     // protocol-complete (upstream 5xx, truncated stream) installed nothing, so
     // it must stop suppressing whoever is still trying to install.
@@ -3766,13 +3845,16 @@ async function selectForwardCandidate(args) {
     return changed ? candidate.body : intended;
 }
 /**
- * Whether delivery would refuse `candidate` sent whole: it is planned over the
- * window, and the measurement selection would use (an exact count, else the
- * same estimate or bytes/4 fallback) does not fit either. Only then is there
- * no fallback, and only then may a compress take the long budget.
+ * Whether delivery would refuse `candidate` sent whole, by delivery's own
+ * admission: it is sendable only when its plan fits and either an exact count
+ * or its conservative per-model bound (with the full max_tokens) fits too;
+ * otherwise the measurement delivery would use (a count, else that bound)
+ * decides. Only when it is refused is there no fallback, and only then may a
+ * compress take the long budget.
  */
 async function wholeRequestRefused(sizing, candidate, limits) {
-    if (fitsNative(sizing.plan(candidate).tokens, limits))
+    if (fitsNative(sizing.plan(candidate).tokens, limits) &&
+        (sizing.isExact(candidate) || sizing.boundFits(candidate, limits)))
         return false;
     return !fitsMeasured(await sizing.measure(candidate, limits), limits);
 }
@@ -4529,6 +4611,7 @@ function readAll(stream) {
 /** Test seam. */
 export const __testCapCacheBreakpoints = capCacheBreakpoints;
 export const __testEstimateRequestTokens = estimateRequestTokens;
+export const __testCompressedResultExceedsWindow = compressedResultExceedsWindow;
 /** Reads message times from the session's transcript, when there is one. */
 function transcriptTimesFor(opts, sessionId, agentId) {
     const source = opts.transcriptUsage;