claude-code-infinite 1.0.11 → 1.0.16

package/dist/reqlog.d.ts

@@ -0,0 +1,427 @@
+/**
+ * Always-on request/timing log (append-only JSONL) for post-hoc incident
+ * reconstruction — when a turn stalls for minutes we want a client-side
+ * record without asking the user to relaunch with --debug.
+ *
+ * Hard constraints:
+ * - NEVER throw and NEVER block the proxy path: every filesystem touch is
+ *   wrapped in try/catch and writes are fire-and-forget (async appendFile
+ *   with an ignored error callback). A broken log path degrades to silence.
+ * - Append-only single file at ~/.claude-code-infinite/logs/requests.jsonl,
+ *   with one rotation slot: if the file exceeds ~20MB at proxy startup it is
+ *   renamed to requests.jsonl.1 (overwriting any previous .1).
+ *
+ * One JSON object per line. `ts` (ISO 8601) and `pid` (the ccc process, which
+ * tells apart concurrent ccc sessions sharing this file) are stamped here so
+ * callers only supply event fields. Token counts under `approxInputTokens` are a rough
+ * bytes/4 chars→tokens proxy, NOT real tokenizer output — exact usage, when
+ * the response format lets us extract it cheaply, lands under `usage`.
+ */
+import type { ClaudeCodeRequestInfo, TranscriptShape } from "./cc-request.js";
+/** Rough bytes→tokens estimate (bytes/4). Label the result approximate. */
+export declare function approxTokensFromBytes(bytes: number): number;
+export declare function defaultLogPath(): string;
+export type TurnType = "first-user" | "tool"
+/** A tool turn sent on its lane's memory route (compressed prefix + suffix). */
+ | "tool-memory"
+/**
+ * A main-thread tool turn sent on the session's stable prefix directly (no
+ * lane route to ride, e.g. after a tool-turn compaction made while a typed
+ * prompt was pending): the prefix bytes, then every later message verbatim.
+ */
+ | "tool-prefix"
+/**
+ * A tool turn that compressed: its estimated size reached the budget (see
+ * `compaction`, reason "budget"), or its lane's route no longer fitted the
+ * context window. Validated compressed bytes were sent to Anthropic; on the
+ * main thread the result is also the session's new stable prefix.
+ */
+ | "tool-recompressed" | "followup-compressed"
+/**
+ * A main-thread human turn sent on the session's stable compressed prefix:
+ * the prefix bytes stored at the last compaction, then every message after
+ * the part it covers, verbatim. No compress call (the history still goes
+ * to MemTree as a background index_only call), and the prefix is a prompt
+ * cache read. See `compaction` for the size check that allowed it.
+ */
+ | "followup-prefix" | "followup-noop"
+/** Indexed response that carried no prior conversation; history forwarded. */
+ | "followup-empty-memory"
+/**
+ * Compressed result carried no server `flattened_messages` (pre-flatten
+ * server or malformed field); history forwarded.
+ */
+ | "followup-no-flatten" | "followup-degraded"
+/**
+ * A fork of the main conversation (the away recap) rode the main thread's
+ * last compressed prefix: same bytes the main thread sent, so Anthropic's
+ * prompt cache hits, and no MemTree call was made.
+ */
+ | "fork-memory"
+/**
+ * Claude Code's own side request (the security monitor): forwarded
+ * untouched, no MemTree call, main-thread route state left alone.
+ */
+ | "side-request"
+/**
+ * Not from Claude Code (no X-Claude-Code-Session-Id): another program that
+ * inherited ccc's ANTHROPIC_BASE_URL. Forwarded untouched, no MemTree.
+ */
+ | "foreign" | "followup-client-closed" | "unparseable";
+/** Real token usage parsed from Anthropic's response, when available. */
+export interface UsageRecord {
+    input_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+    output_tokens?: number;
+}
+/**
+ * One /v1/messages request through the proxy. Built up mutably as the request
+ * flows through the forward path (the forwarders fill in upstream timing) and
+ * written once when the response finishes. Fields that a given path can't
+ * derive cheaply are simply omitted.
+ */
+/** One actual Count Tokens HTTP attempt; never includes body, credentials or token counts. */
+export interface CountTokensRecord {
+    statusClass: string;
+    ms: number;
+}
+export interface MessagesRecord {
+    kind: "messages";
+    turnType: TurnType;
+    /** Body bytes as received from Claude Code. */
+    requestBytes: number;
+    model?: string;
+    stream?: boolean;
+    /** For a foreign request: the opening of its User-Agent, to name the program. */
+    userAgent?: string;
+    /**
+     * What Claude Code's billing header says about this request (see
+     * cc-request.ts). Logged to measure which request kinds lack
+     * `cc_turn_origin` before any of them are kept away from MemTree.
+     */
+    client?: ClaudeCodeRequestInfo;
+    /**
+     * For a request shaped like Claude Code's security monitor (billing header,
+     * no turn origin, no tools): whether its `<transcript>` block has the known
+     * format. `ok: false` means it was handled as an ordinary request, and is
+     * the signal that Claude Code changed the format.
+     */
+    transcript?: TranscriptShape;
+    /** The request's max_tokens (output reservation counted against the window). */
+    maxTokens?: number;
+    /**
+     * The compress result showed MemTree's index trailing the conversation
+     * (indexLagEvidence: the server's index_pending, or a cold pass-through with
+     * its page). If the request then cannot fit, the refusal waits for indexing.
+     */
+    indexBehind?: true;
+    /** Body bytes actually sent to Anthropic (after notice strip / compression). */
+    forwardedBytes?: number;
+    /** forwardedBytes/4 — rough chars→tokens proxy, not a tokenizer count. */
+    approxInputTokens?: number;
+    /** Present when a blocking MemTree compress was attempted for this turn. */
+    compress?: {
+        /** Overall wall time of the compress step (all concurrent legs). */
+        ms: number;
+        /**
+         * The compress call returned a result. NOT a
+         * "forwarded compressed history" flag: the proxy can still discard the
+         * result afterwards (no-op response, or indexed-but-empty memory) and
+         * forward the full history — `turnType` (followup-noop /
+         * followup-empty-memory vs followup-compressed) and `history.usable`
+         * record what actually happened.
+         */
+        ok: boolean;
+        /**
+         * The compress call consumed (roughly) the whole compress budget and
+         * returned nothing.
+         */
+        timedOut: boolean;
+    };
+    /**
+     * How much conversation the compressed response actually carried. Recorded
+     * separately from `compress.ok` because a fully indexed response can still
+     * return an empty conversation; this is the field that shows it.
+     */
+    history?: {
+        retainedChars: number;
+        priorHistoryChars: number;
+        usable: boolean;
+    };
+    /**
+     * Which memory-route lane this request keys to: the away-summary side
+     * channel, a request carrying agent attribution, or the main thread. This
+     * is what splits verbatim `tool` rows into main-miss vs subagent traffic
+     * when evaluating recovery behaviour after the fact.
+     */
+    routeLane?: "main" | "away" | "agent";
+    /**
+     * Tool turns that missed their lane's route: "missing" (empty lane),
+     * "rejected" (a route was present in this lane but unusable for this
+     * request), or "replay" (the body was an exact replay of the request that
+     * installed the route — a client retry after a pre-flush socket death —
+     * forwarded verbatim with the route retained and no recovery attempt).
+     * "rejected" covers every OTHER reason memoryRoutedToolBody refuses:
+     * a changed system/prefix hash, a conversation that shrank below the
+     * stored prefix, an unexpected tool suffix shape, or an assembled route
+     * estimated to exceed the destination context window. (An epoch-stale
+     * route never reaches rejection: getMemoryRoute drops it on lookup, so
+     * that case logs "missing".) "superseded": a main-thread route built on
+     * an older stable prefix than the session's current one (a later tool-turn
+     * compaction replaced the prefix without owning the route); dropped, and
+     * the turn rides the current prefix instead.
+     * Absent means there was no applicable miss — hits and away-summary turns
+     * never emit it. "none" is deliberately not a value.
+     */
+    routeMiss?: "missing" | "rejected" | "replay" | "superseded";
+    /**
+     * The request's last conversation message was neither a user prompt nor a
+     * tool result: e.g. a background task notification, which Claude Code
+     * sends as a trailing role=system block after the assistant's last reply.
+     * Handled like a tool turn (stable-prefix ride, budget compaction) without
+     * consulting the lane's route. Absent on every other request.
+     */
+    continuation?: true;
+    /**
+     * Why a fork of the main conversation (away recap) did not ride the main
+     * thread's last prefix and fell back to its own compression; absent when it
+     * rode (turnType "fork-memory") or was not a fork.
+     */
+    forkMiss?: "no-route" | "session" | "system" | "prefix" | "too-large";
+    /**
+     * Stable-prefix (edge) compaction: the budget the turn was measured
+     * against, the size estimate, and, when it compacted, why. Recorded on
+     * main-thread human turns and on every lane's tool turns (a tool turn under
+     * the budget forwards with no compress call; at the budget it compresses
+     * once, reason "budget"). Absent on other requests, and on tool turns under
+     * the CCC_TOOL_ROUTE_RECOVERY=0 kill switch.
+     */
+    compaction?: CompactionRecord;
+    /** Every actual counting attempt, in order; cached results add no entry. */
+    countTokens?: CountTokensRecord[];
+    /** One bounded compression after an assembled ride was counted above the soft budget. */
+    lateCountRecovery?: {
+        outcome: "compressed" | "forwarded" | "refused";
+    };
+    /** Searchable flag explaining a forward above the advisory compression budget. */
+    overBudgetForward?: {
+        reason: "exact-count-fits-window" | "estimate-fits-window" | "bytes-fallback-fits-window";
+    };
+    /**
+     * Outcome of a tool-turn compaction attempt (a tool turn whose estimated
+     * size reached the budget), or why none was made although one was due.
+     * Absent on tool turns under the budget: they forward with no attempt.
+     */
+    routeRecovery?: {
+        /**
+         * Serialized non-system conversation bytes, measured once per attempt.
+         * Absent when no attempt was made (kill switch, cooldown, in-flight,
+         * backoff, awaiting-index).
+         */
+        conversationBytes?: number;
+        outcome: "compressed" | "failed"
+        /** The server returned the conversation uncompressed (index warming). */
+         | "noop" | "unusable"
+        /**
+         * Compressed result carried no server `flattened_messages`
+         * (pre-flatten server or malformed field). Forwarded the original.
+         */
+         | "no-flatten" | "no-gain" | "client-closed"
+        /**
+         * CCC_TOOL_ROUTE_RECOVERY=0: a route miss that got no size check and
+         * no attempt.
+         */
+         | "disabled"
+        /** A recent attempt returned null; the blocking wait was skipped. */
+         | "cooldown"
+        /** Another attempt for this lane is still in flight. */
+         | "in-flight"
+        /**
+         * This lane's last attempt this human turn produced no prefix to ride
+         * (no-op, no gain, failure, a forward that installed nothing, or a
+         * result still over the window from a complete index); the next one
+         * waits until the conversation has grown by a twentieth of the budget, so a lane that
+         * cannot compress does not pay a blocking call on every tool turn.
+         */
+         | "backoff"
+        /**
+         * This lane's last attempt found no finished tree for the conversation
+         * (no-op, nothing indexed), so a compress call could only pass it
+         * through again. None is made until that attempt's MemTree page
+         * reports built (checked in the background, one fetch at a time).
+         */
+         | "awaiting-index"
+        /**
+         * The compressed result could not be serialized (e.g. V8 string-length
+         * limit on a multi-megabyte body). Forwarded the original.
+         */
+         | "build-failed";
+        /**
+         * Main-thread compactions with a session: whether the result became the
+         * session's stable prefix ("not-installed": the forward never completed,
+         * or a newer prefix replaced the one this compaction started from).
+         */
+        prefix?: "installed" | "not-installed";
+        /** A no-op that found no tree: the lane now waits for one ("awaiting-index"). */
+        awaitingIndex?: boolean;
+        /** Route candidate fate; only "compressed" outcomes carry it. */
+        install?: "installed" | "stale" | "prompt-pending" | "no-session"
+        /**
+         * The recovered forward never reached protocol-complete and the
+         * downstream client had NOT aborted. Typically an upstream 5xx/529
+         * or a truncated upstream stream, but any non-2xx of the compressed
+         * forward lands here — including a plain 4xx, which is deliberately
+         * non-arming for the fuse — as does proxy-shutdown teardown of an
+         * in-flight recovery. Lifts the lane's backoff so the identical-body
+         * retry compresses again.
+         */
+         | "upstream-failed"
+        /**
+         * The upstream served the turn to protocol-complete but route
+         * bookkeeping threw at an activation attempt (the protocol-complete
+         * attempt, the delivered-settle retry, or both), so no route exists.
+         * Releases the lane's reservation but keeps its backoff. In the common
+         * sub-case the client got its complete answer — a fast-tool abort
+         * after message_stop lands here, not in "client-aborted" — so no
+         * identical-body retry is coming, and the throw is not
+         * upstream-health evidence. Rarer closes land here too: a socket
+         * that dies before the accepted message_stop bytes flush (which
+         * DOES retry the identical body) and an upstream-owned error
+         * arriving after the data chunk that carried message_stop. A retry
+         * finds its lane backed off and forwards uncompressed until the
+         * history grows past the retry size or the next human turn — a
+         * bounded degradation accepted because the closes are
+         * indistinguishable at settle time and lifting the backoff would
+         * fund one blocking recompress per tool turn under a deterministic
+         * activation throw.
+         */
+         | "activation-error"
+        /**
+         * The downstream client aborted mid-stream before protocol-complete.
+         * Lifts the backoff exactly like upstream-failed (no route exists
+         * and the client's identical-body retry is imminent) but is split
+         * out so attempt-rate tripwires can tell client behavior from
+         * upstream health.
+         */
+         | "client-aborted";
+    };
+    upstreamStatus?: number;
+    /** The downstream client aborted before the response finished. */
+    clientAborted?: true;
+    /** Forward start → first response byte from Anthropic. */
+    ttfbMs?: number;
+    /** Forward start → first upstream content_block_delta (SSE only). */
+    firstContentMs?: number;
+    /** Request received → response fully sent to Claude Code. */
+    totalMs?: number;
+    /** Legacy schema field; live response fabrication is disabled. */
+    preludeFired?: boolean;
+    usage?: UsageRecord;
+}
+/** Why a turn compressed instead of riding its prefix (or passing through). */
+export type RecompressReason = 
+/** The prefix plus the turns after it reached the budget. */
+"budget"
+/** The messages the prefix covers changed: rewind, edit, fork, /clear. */
+ | "prefix-mismatch"
+/** `/memtree-compact [N]` asked for a compaction now. */
+ | "manual"
+/** The session's target or context window changed since the prefix was built. */
+ | "target-change";
+export interface CompactionRecord {
+    /** "off" after `/memtree-compact off`; "explicit" for an N or CCC_COMPACT_TARGET. */
+    mode: "auto" | "explicit" | "off";
+    /** The whole-request budget the turn was measured against. */
+    budgetTokens: number;
+    /**
+     * Where the budget came from: CCC_BUDGET_TOKENS ("override"), the
+     * server's `model_budget_tokens` ("server"), or the model's context window
+     * times FALLBACK_BUDGET_WINDOW_RATIO until the server reports one.
+     */
+    budgetSource: "override" | "server" | "window-ratio";
+    /** What a compaction on this turn aims at (budget/2, or the explicit N). */
+    targetTokens?: number;
+    /** Sent as compression_threshold_tokens (servers that report a budget). */
+    thresholdTokens?: number;
+    /** Size estimate of what would be sent (prefix ride or full history). */
+    estimatedTokens?: number;
+    /** Bytes of the request underlying estimatedTokens, including a reused prefix. */
+    estimatedBytes?: number;
+    /**
+     * "reported": Anthropic's input+cache_read+cache_creation for the previous
+     * request of the same shape, plus bytes/4 for what was added since.
+     * "bytes": bytes/4 of the whole body (no earlier usage to start from).
+     */
+    sizeSource?: "reported" | "bytes";
+    /** Set when the turn compressed (or tried to) for one of these reasons. */
+    reason?: RecompressReason;
+    /** For "prefix-mismatch": which check failed. */
+    prefixMiss?: "session" | "system" | "prefix";
+    /**
+     * A compaction was attempted but did not produce a new prefix (MemTree
+     * down, no-op, unusable) and the turn rode the old prefix instead.
+     */
+    keptPrefix?: true;
+}
+/** One MemTree API call (blocking compress or background index). */
+export interface MemtreeRecord {
+    kind: "memtree";
+    indexOnly: boolean;
+    ms: number;
+    ok: boolean;
+    /** HTTP status; absent when the call died before a response (network/timeout). */
+    status?: number;
+    requestBytes: number;
+    /** Model sent for server-side budget resolution (compression calls only). */
+    model?: string;
+    /**
+     * Response diagnostics, present on successful calls that reported usage.
+     * `indexedTokens` (cached_tokens) is the prompt coverage of the index and
+     * drives the success notice: flat coverage across turns means MemTree
+     * indexed nothing new. `memoryChars` moves independently of it because the
+     * index is unfolded per question.
+     */
+    indexedTokens?: number;
+    rawPromptTokens?: number;
+    memoryChars?: number;
+    /** The per-request MemTree page the server stamped on the response, if any. */
+    memtreeUrl?: string;
+    /** The completed index the turn was compressed against, if the server said. */
+    memtreeIndex?: string;
+    /** The server's model budget (`model_budget_tokens`), when it reported one. */
+    modelBudgetTokens?: number;
+}
+/** A display-only notice was atomically claimed by one Claude Code hook. */
+export interface NoticeRecord {
+    kind: "notice";
+    event: "claimed";
+    via: "MessageDisplay" | "Stop";
+}
+export type RequestRecord = MessagesRecord | MemtreeRecord | NoticeRecord;
+/** Structural logging seam retained for embedders and focused tests. */
+export interface RequestLogSink {
+    log(record: RequestRecord): void;
+}
+export declare class RequestLogger implements RequestLogSink {
+    readonly path: string;
+    private readonly pendingWrites;
+    constructor(filePath?: string);
+    /** Fire-and-forget append of one JSONL line. Never throws, never blocks. */
+    log(record: RequestRecord): void;
+    /**
+     * Shutdown-only durability seam. Wait for already-scheduled appends without
+     * making normal proxy logging synchronous; false means the bounded wait
+     * expired. Callers should stop request producers before invoking this.
+     */
+    flush(timeoutMs?: number): Promise<boolean>;
+}
+/**
+ * Merge token usage out of a parsed SSE event into a record. Anthropic sends
+ * input/cache counts on message_start and the final output count (plus
+ * occasionally refreshed input counts) on message_delta.
+ */
+export declare function mergeUsageFromSseEvent(data: any, rec: MessagesRecord): void;
+/** Merge usage from a non-streaming /v1/messages JSON response body. */
+export declare function mergeUsageFromJsonBody(body: Buffer, rec: MessagesRecord): void;
+//# sourceMappingURL=reqlog.d.ts.map

package/dist/reqlog.d.ts.map

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

package/dist/reqlog.js

@@ -0,0 +1,146 @@
+/**
+ * Always-on request/timing log (append-only JSONL) for post-hoc incident
+ * reconstruction — when a turn stalls for minutes we want a client-side
+ * record without asking the user to relaunch with --debug.
+ *
+ * Hard constraints:
+ * - NEVER throw and NEVER block the proxy path: every filesystem touch is
+ *   wrapped in try/catch and writes are fire-and-forget (async appendFile
+ *   with an ignored error callback). A broken log path degrades to silence.
+ * - Append-only single file at ~/.claude-code-infinite/logs/requests.jsonl,
+ *   with one rotation slot: if the file exceeds ~20MB at proxy startup it is
+ *   renamed to requests.jsonl.1 (overwriting any previous .1).
+ *
+ * One JSON object per line. `ts` (ISO 8601) and `pid` (the ccc process, which
+ * tells apart concurrent ccc sessions sharing this file) are stamped here so
+ * callers only supply event fields. Token counts under `approxInputTokens` are a rough
+ * bytes/4 chars→tokens proxy, NOT real tokenizer output — exact usage, when
+ * the response format lets us extract it cheaply, lands under `usage`.
+ */
+import { appendFile, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getConfigDir } from "./config.js";
+const MAX_LOG_BYTES = 20 * 1024 * 1024; // rotate above ~20MB at startup
+const APPROX_CHARS_PER_TOKEN = 4;
+/** Rough bytes→tokens estimate (bytes/4). Label the result approximate. */
+export function approxTokensFromBytes(bytes) {
+    return Math.round(bytes / APPROX_CHARS_PER_TOKEN);
+}
+export function defaultLogPath() {
+    return join(getConfigDir(), "logs", "requests.jsonl");
+}
+export class RequestLogger {
+    path;
+    pendingWrites = new Set();
+    constructor(filePath) {
+        this.path = filePath ?? defaultLogPath();
+        try {
+            mkdirSync(dirname(this.path), { recursive: true });
+            rotateIfLarge(this.path);
+        }
+        catch {
+            // Unwritable/odd log location: run silent, never break startup.
+        }
+    }
+    /** Fire-and-forget append of one JSONL line. Never throws, never blocks. */
+    log(record) {
+        try {
+            const line = JSON.stringify({ ts: new Date().toISOString(), pid: process.pid, ...record }) + "\n";
+            let finish;
+            const pending = new Promise((resolve) => {
+                finish = resolve;
+            });
+            const settle = () => {
+                this.pendingWrites.delete(pending);
+                finish();
+            };
+            this.pendingWrites.add(pending);
+            try {
+                appendFile(this.path, line, settle);
+            }
+            catch {
+                settle();
+            }
+        }
+        catch {
+            // Serialization/scheduling failure — same policy.
+        }
+    }
+    /**
+     * Shutdown-only durability seam. Wait for already-scheduled appends without
+     * making normal proxy logging synchronous; false means the bounded wait
+     * expired. Callers should stop request producers before invoking this.
+     */
+    async flush(timeoutMs = 2_000) {
+        const boundedMs = Number.isFinite(timeoutMs) && timeoutMs >= 0
+            ? Math.floor(timeoutMs)
+            : 2_000;
+        const deadline = Date.now() + boundedMs;
+        while (this.pendingWrites.size > 0) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                return false;
+            let timer;
+            const completed = await Promise.race([
+                Promise.allSettled([...this.pendingWrites]).then(() => true),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), remaining);
+                }),
+            ]);
+            if (timer)
+                clearTimeout(timer);
+            if (!completed)
+                return false;
+        }
+        return true;
+    }
+}
+/**
+ * Merge token usage out of a parsed SSE event into a record. Anthropic sends
+ * input/cache counts on message_start and the final output count (plus
+ * occasionally refreshed input counts) on message_delta.
+ */
+export function mergeUsageFromSseEvent(data, rec) {
+    const type = data?.type;
+    if (type === "message_start")
+        mergeUsage(data?.message?.usage, rec);
+    else if (type === "message_delta")
+        mergeUsage(data?.usage, rec);
+}
+/** Merge usage from a non-streaming /v1/messages JSON response body. */
+export function mergeUsageFromJsonBody(body, rec) {
+    try {
+        mergeUsage(JSON.parse(body.toString("utf-8"))?.usage, rec);
+    }
+    catch {
+        // Not the shape we expected — usage just stays absent.
+    }
+}
+const USAGE_FIELDS = [
+    "input_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+    "output_tokens",
+];
+function mergeUsage(usage, rec) {
+    if (!usage || typeof usage !== "object")
+        return;
+    for (const field of USAGE_FIELDS) {
+        const value = usage[field];
+        if (typeof value !== "number")
+            continue;
+        rec.usage = rec.usage ?? {};
+        rec.usage[field] = value;
+    }
+}
+/** Startup size protection: one rotation slot, old .1 is overwritten. */
+function rotateIfLarge(path) {
+    try {
+        if (statSync(path).size > MAX_LOG_BYTES)
+            renameSync(path, `${path}.1`);
+    }
+    catch {
+        // Missing file (fresh install) or unreadable — nothing to rotate.
+    }
+}
+//# sourceMappingURL=reqlog.js.map

package/dist/reqlog.js.map

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

package/dist/request-sizing.d.ts

@@ -0,0 +1,74 @@
+import { type CountTokensSession, type CountTokensResult, type SizeSample } from "./count-tokens.js";
+/** Output room kept free on models that accept input + max_tokens over the
+ * window, so the model can still answer a request that barely fits. */
+export declare const OUTPUT_FLOOR_TOKENS = 16000;
+export type CandidateKind = "original" | "ride" | "replacement";
+export interface SizingLimits {
+    budget: number;
+    context: number;
+    /** Output room an exact count must leave (see outputReservation). */
+    output: number;
+    /** Full max_tokens, reserved for every estimate: an estimate that would not
+     * fit with it is counted before delivery, and only an exact count may use
+     * the relaxed `output` floor. */
+    recountOutput?: number;
+}
+export interface PlannedSize {
+    tokens: number;
+    source: "reported" | "bytes";
+}
+export interface CandidateMeasurement {
+    tokens: number;
+    source: "exact" | "reported" | "bytes";
+    /** Advisory estimate retained for compression and stale-estimate diagnostics. */
+    estimatedTokens: number;
+    count?: CountTokensResult;
+}
+export interface RequestCandidate {
+    readonly key: string;
+    /** Owned copy: callers must not mutate these bytes. */
+    readonly body: Buffer;
+    readonly kind: CandidateKind;
+    readonly sample?: Readonly<SizeSample>;
+    readonly estimate: Readonly<PlannedSize>;
+}
+export declare class RequestSizing {
+    private readonly counts;
+    private readonly enabled;
+    private readonly candidates;
+    private readonly excludedFallbacks;
+    constructor(counts: CountTokensSession, enabled: boolean);
+    /** The first registration fixes both bytes and learned sample for this request. */
+    register(body: Buffer, kind: CandidateKind, sample?: SizeSample): RequestCandidate;
+    /** Eligibility belongs to route planning, not to a later byte-size guess. */
+    excludeFallback(candidate: RequestCandidate): void;
+    /** Planning and metadata consult the same exact count, else the snapshotted estimate. */
+    plan(candidate: RequestCandidate): PlannedSize;
+    /** Whether this body's size is an exact Count Tokens result. */
+    isExact(candidate: RequestCandidate): boolean;
+    clientInputTokens(candidate: RequestCandidate): number | undefined;
+    /** Count only when a size decision needs it; all views reuse the same result. */
+    measure(candidate: RequestCandidate, limits: SizingLimits, phase?: "plan" | "delivery"): Promise<CandidateMeasurement>;
+    /** The preferred body gets first chance; only validated registered candidates
+     * are considered afterward. Exact overflow never degrades to a byte guess. */
+    select(preferred: RequestCandidate, limits: SizingLimits): Promise<{
+        candidate: RequestCandidate;
+        measurement: CandidateMeasurement;
+    } | undefined>;
+}
+/** Tokens a fit check must leave free for output. Claude 4.5+ rejects a
+ * request only when its input alone exceeds the window (platform.claude.com/
+ * docs/en/build-with-claude/context-windows, "Context window overflow
+ * behavior"), so those models reserve min(max_tokens, OUTPUT_FLOOR_TOKENS);
+ * older and unknown models reserve the full max_tokens. */
+export declare function outputReservation(model: string | undefined, maxTokens: unknown): number;
+/** Admission: the relaxed output floor applies only to an exact count of this
+ * body; estimates and fallbacks (failed or disabled counting) keep max_tokens. */
+export declare function fitsMeasured(measurement: Pick<CandidateMeasurement, "tokens" | "source">, limits: SizingLimits): boolean;
+/** The limits an estimate is judged by: the full max_tokens reservation. */
+export declare function estimateLimits(limits: SizingLimits): SizingLimits;
+/** `limits.output` is the reservation from outputReservation, not raw max_tokens. */
+export declare function fitsNative(input: number, limits: SizingLimits): boolean;
+/** One shared estimator for planner telemetry and request-local snapshots. */
+export declare function estimateRequestTokens(sample: SizeSample | undefined, bytes: number): PlannedSize;
+//# sourceMappingURL=request-sizing.d.ts.map