@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/context/fileSummarizer.js

@@ -1,146 +0,0 @@
-/**
- * File Content Summarization Pipeline
- *
- * Provides utilities to detect when attached file content exceeds the
- * model's available context budget and to plan / build prompts for
- * LLM-driven summarization of the largest files.
- *
- * Design rationale:
- *  - Files are the #1 cause of context overflow when users attach
- *    multiple large documents (PDFs, spreadsheets, source code).
- *  - Rather than blindly truncating, we ask an LLM to produce a
- *    *context-aware* summary that retains the information most
- *    relevant to the user's actual question.
- *  - The caller (FileSummarizationService) is responsible for the
- *    actual LLM calls; this module is pure computation + types.
- */
-import { getAvailableInputTokens } from "../constants/contextWindows.js";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-/** Fraction of the context window reserved for non-file content overhead */
-export const NON_FILE_RESERVE = 0.15;
-/** Minimum tokens a single file can be allocated in the plan */
-export const MIN_PER_FILE_TOKENS = 500;
-/** Maximum tokens a single file can be allocated in the plan */
-export const MAX_PER_FILE_TOKENS = 4000;
-/**
- * Files with fewer estimated tokens than this threshold are never
- * summarized — they're already small enough to include verbatim.
- */
-export const FILE_SUMMARIZATION_THRESHOLD = 1000;
-// ---------------------------------------------------------------------------
-// Functions
-// ---------------------------------------------------------------------------
-/**
- * Check whether the attached files push the total input token count
- * beyond the model's available context window.
- *
- * When the total exceeds the budget, we calculate how many tokens are
- * available for files (after accounting for system prompt, conversation
- * history, current prompt, and tool definitions) and divide that
- * equally across all files to derive a per-file budget.
- */
-export function shouldSummarizeFiles(params) {
-    const { provider, model, systemPromptTokens, conversationHistoryTokens, currentPromptTokens, toolDefinitionTokens, fileTokens, fileCount = 1, maxTokens, threshold = 0.8, minTokensPerFile = MIN_PER_FILE_TOKENS, maxTokensPerFile = MAX_PER_FILE_TOKENS, } = params;
-    const availableInputTokens = getAvailableInputTokens(provider, model, maxTokens);
-    const nonFileTokens = systemPromptTokens +
-        conversationHistoryTokens +
-        currentPromptTokens +
-        toolDefinitionTokens;
-    const totalEstimatedTokens = nonFileTokens + fileTokens;
-    // Budget for files = available input minus non-file content minus a reserve
-    const reserveTokens = Math.ceil(availableInputTokens * NON_FILE_RESERVE);
-    const availableBudgetForFiles = Math.max(0, availableInputTokens - nonFileTokens - reserveTokens);
-    const usageRatio = availableInputTokens > 0 ? totalEstimatedTokens / availableInputTokens : 1;
-    const needsSummarization = usageRatio >= threshold || fileTokens > availableBudgetForFiles;
-    let perFileBudget;
-    if (needsSummarization && fileCount > 0) {
-        const rawBudget = Math.floor(availableBudgetForFiles / fileCount);
-        perFileBudget = Math.max(minTokensPerFile, Math.min(maxTokensPerFile, rawBudget));
-    }
-    return {
-        needsSummarization,
-        totalEstimatedTokens,
-        availableInputTokens,
-        availableBudgetForFiles,
-        perFileBudget,
-    };
-}
-/**
- * Build the LLM prompt used to summarize a single file's content.
- *
- * The prompt is *context-aware*: it includes the user's original question
- * so the LLM can prioritise the most relevant parts of the file.
- */
-export function buildFileSummarizationPrompt(params) {
-    const { fileName, fileType, fileContent, userPrompt, targetTokens } = params;
-    return [
-        `You are a document summarization assistant. Your task is to summarize the following ${fileType} file in a way that preserves the most important information relevant to the user's question.`,
-        ``,
-        `## User's Question`,
-        `${userPrompt}`,
-        ``,
-        `## File: ${fileName} (${fileType})`,
-        ``,
-        `${fileContent}`,
-        ``,
-        `## Instructions`,
-        `1. Produce a concise summary of the file content above.`,
-        `2. Focus on information that is most relevant to the user's question.`,
-        `3. Preserve key data points, names, numbers, and relationships.`,
-        `4. Target approximately ${targetTokens} tokens in your summary.`,
-        `5. If the file contains structured data (tables, lists), preserve the structure in a compact form.`,
-        `6. Start your summary directly — do not include preamble like "Here is a summary".`,
-    ].join("\n");
-}
-/**
- * Decide which files need summarization and how much budget each gets.
- *
- * Strategy:
- *  1. Sort files largest-first.
- *  2. Walk through the list, marking the largest files for summarization
- *     until the cumulative saved tokens bring us under budget.
- *  3. Files below `FILE_SUMMARIZATION_THRESHOLD` are never summarized.
- */
-export function planFileSummarization(files, params) {
-    const checkResult = shouldSummarizeFiles({
-        ...params,
-        fileCount: files.length,
-    });
-    // If no summarization needed, keep everything
-    if (!checkResult.needsSummarization) {
-        return files.map((file) => ({ file, action: "keep" }));
-    }
-    // Sort largest first (descending by estimatedTokens)
-    const sorted = [...files].sort((a, b) => b.estimatedTokens - a.estimatedTokens);
-    const perFileBudget = checkResult.perFileBudget ?? MAX_PER_FILE_TOKENS;
-    // Calculate how many tokens we need to save
-    const totalFileTokens = files.reduce((sum, f) => sum + f.estimatedTokens, 0);
-    const tokensToSave = Math.max(0, totalFileTokens - checkResult.availableBudgetForFiles);
-    let savedSoFar = 0;
-    const plan = [];
-    for (const file of sorted) {
-        // Never summarize tiny files
-        if (file.estimatedTokens < FILE_SUMMARIZATION_THRESHOLD ||
-            savedSoFar >= tokensToSave) {
-            plan.push({ file, action: "keep" });
-        }
-        else {
-            const savingsFromThisFile = file.estimatedTokens - perFileBudget;
-            if (savingsFromThisFile > 0) {
-                plan.push({
-                    file,
-                    action: "summarize",
-                    targetTokens: perFileBudget,
-                });
-                savedSoFar += savingsFromThisFile;
-            }
-            else {
-                plan.push({ file, action: "keep" });
-            }
-        }
-    }
-    return plan;
-}
-//# sourceMappingURL=fileSummarizer.js.map

package/dist/lib/context/fileTokenBudget.d.ts

@@ -1,52 +0,0 @@
-/**
- * File Token Budget System
- *
- * Calculates how much of the remaining context window budget
- * can be used for file reads. Implements fast-path for small files
- * and preview mode for very large files.
- */
-import type { BudgetFileInput } from "../types/index.js";
-/** Percentage of remaining context to allocate for file reads */
-export declare const FILE_READ_BUDGET_PERCENT = 0.6;
-/** Files below this size skip budget validation (100KB) */
-export declare const FILE_FAST_PATH_SIZE: number;
-/** Files above this size get preview-only mode (5MB) */
-export declare const FILE_PREVIEW_MODE_SIZE: number;
-/** Default preview size in characters */
-export declare const FILE_PREVIEW_CHARS = 2000;
-/**
- * Calculate available token budget for file reads.
- *
- * @param contextWindow - Total context window for the model
- * @param currentTokens - Tokens already used (conversation + system prompt)
- * @param maxOutputTokens - Reserved output tokens
- * @returns Available tokens for file content
- */
-export declare function calculateFileTokenBudget(contextWindow: number, currentTokens: number, maxOutputTokens: number): number;
-/**
- * Determine how a file should be handled based on its size and the budget.
- */
-export declare function shouldTruncateFile(fileSize: number, budget: number): {
-    shouldTruncate: boolean;
-    maxChars?: number;
-    previewMode?: boolean;
-};
-/**
- * Estimate post-processing token count based on file type.
- *
- * Different file types produce vastly different amounts of text after
- * processing.  A 50 MB video file yields ~200-500 tokens of metadata,
- * while a 50 MB text file yields ~12.5 M tokens.  Using the raw byte
- * size for all types causes media files to be wrongly excluded by the
- * aggregate budget check.
- *
- * @param sizeBytes  Raw file size in bytes
- * @param fileType   Detected file type (e.g. "video", "audio", "image")
- * @returns Estimated token count after processing
- */
-export declare function estimatePostProcessingTokens(sizeBytes: number, fileType?: string): number;
-export declare function enforceAggregateFileBudget(files: BudgetFileInput[], availableTokens: number): {
-    included: BudgetFileInput[];
-    excluded: BudgetFileInput[];
-    notices: string[];
-};

package/dist/lib/context/fileTokenBudget.js

@@ -1,128 +0,0 @@
-/**
- * File Token Budget System
- *
- * Calculates how much of the remaining context window budget
- * can be used for file reads. Implements fast-path for small files
- * and preview mode for very large files.
- */
-/** Percentage of remaining context to allocate for file reads */
-export const FILE_READ_BUDGET_PERCENT = 0.6;
-/** Files below this size skip budget validation (100KB) */
-export const FILE_FAST_PATH_SIZE = 100 * 1024;
-/** Files above this size get preview-only mode (5MB) */
-export const FILE_PREVIEW_MODE_SIZE = 5 * 1024 * 1024;
-/** Default preview size in characters */
-export const FILE_PREVIEW_CHARS = 2000;
-/**
- * Calculate available token budget for file reads.
- *
- * @param contextWindow - Total context window for the model
- * @param currentTokens - Tokens already used (conversation + system prompt)
- * @param maxOutputTokens - Reserved output tokens
- * @returns Available tokens for file content
- */
-export function calculateFileTokenBudget(contextWindow, currentTokens, maxOutputTokens) {
-    const remainingTokens = contextWindow - currentTokens - maxOutputTokens;
-    if (remainingTokens <= 0) {
-        return 0;
-    }
-    return Math.floor(remainingTokens * FILE_READ_BUDGET_PERCENT);
-}
-/**
- * Determine how a file should be handled based on its size and the budget.
- */
-export function shouldTruncateFile(fileSize, budget) {
-    // Very large files: preview mode
-    if (fileSize > FILE_PREVIEW_MODE_SIZE) {
-        return {
-            shouldTruncate: true,
-            maxChars: FILE_PREVIEW_CHARS,
-            previewMode: true,
-        };
-    }
-    // Small files: skip validation
-    if (fileSize < FILE_FAST_PATH_SIZE) {
-        return { shouldTruncate: false };
-    }
-    // Estimate tokens (4 chars per token, rough)
-    const estimatedTokens = Math.ceil(fileSize / 4);
-    if (estimatedTokens <= budget) {
-        return { shouldTruncate: false };
-    }
-    // Truncate to fit budget
-    const maxChars = budget * 4; // Convert back to chars
-    return {
-        shouldTruncate: true,
-        maxChars: Math.max(FILE_PREVIEW_CHARS, maxChars),
-        previewMode: false,
-    };
-}
-/**
- * Estimate post-processing token count based on file type.
- *
- * Different file types produce vastly different amounts of text after
- * processing.  A 50 MB video file yields ~200-500 tokens of metadata,
- * while a 50 MB text file yields ~12.5 M tokens.  Using the raw byte
- * size for all types causes media files to be wrongly excluded by the
- * aggregate budget check.
- *
- * @param sizeBytes  Raw file size in bytes
- * @param fileType   Detected file type (e.g. "video", "audio", "image")
- * @returns Estimated token count after processing
- */
-export function estimatePostProcessingTokens(sizeBytes, fileType) {
-    switch (fileType) {
-        // Media files produce only metadata text (~100-500 tokens)
-        case "video":
-            return 500;
-        case "audio":
-            return 300;
-        // Images are sent as base64 — provider counts them as ~1500 tokens each
-        case "image":
-            return 1500;
-        // Archives produce a file listing (~500-2000 tokens)
-        case "archive":
-            return 1000;
-        // Unknown binary files produce metadata + extracted strings (~200-1000 tokens)
-        case "unknown":
-            return 500;
-        // PDFs are sent natively on some providers; estimate ~1 token per 100 bytes, capped
-        case "pdf":
-            return Math.min(Math.ceil(sizeBytes / 100), 50_000);
-        // Structured documents (Excel, Word, PPTX) extract text — roughly 15% of raw size
-        case "xlsx":
-        case "docx":
-        case "pptx":
-            return Math.ceil((sizeBytes * 0.15) / 4);
-        // SVG is sanitized markup — usually small
-        case "svg":
-            return Math.ceil(sizeBytes / 4);
-        // CSV, text, code — raw text roughly 1 token per 4 bytes
-        case "csv":
-        case "text":
-        default:
-            // Original formula: base64-inflate then divide by 4
-            return Math.ceil((sizeBytes * 1.33) / 4);
-    }
-}
-export function enforceAggregateFileBudget(files, availableTokens) {
-    const TOKEN_BUDGET_FOR_FILES = Math.floor(availableTokens * FILE_READ_BUDGET_PERCENT);
-    let usedTokens = 0;
-    const included = [];
-    const excluded = [];
-    const notices = [];
-    const sorted = [...files].sort((a, b) => a.sizeBytes - b.sizeBytes);
-    for (const file of sorted) {
-        const estimatedTokens = estimatePostProcessingTokens(file.sizeBytes, file.fileType);
-        if (usedTokens + estimatedTokens <= TOKEN_BUDGET_FOR_FILES) {
-            usedTokens += estimatedTokens;
-            included.push(file);
-        }
-        else {
-            excluded.push(file);
-            notices.push(`Skipped "${file.name}" (${(file.sizeBytes / 1024).toFixed(0)} KB) — exceeds context budget`);
-        }
-    }
-    return { included, excluded, notices };
-}
-//# sourceMappingURL=fileTokenBudget.js.map

package/dist/lib/context/geminiLoopGuard.d.ts

@@ -1,54 +0,0 @@
-/**
- * In-turn context guard for Gemini-shaped agent loops (native Vertex + AI
- * Studio + Gemini 3).
- *
- * These loops already had `createContextGuard`, but it is **stop-only**: once
- * the projected prompt crosses the threshold it breaks the loop and synthesizes
- * an answer from whatever it has. That avoids a provider rejection, but it also
- * ends the turn early — the model stops doing work it was mid-way through.
- *
- * This module brings them to parity with the other loops: reclaim budget and
- * CONTINUE, falling back to the existing stop only when reclaiming cannot get
- * back under the line. The reclaim policy is shared with every other provider
- * via `loopGuardCore`; this module owns only the Gemini shape mapping.
- *
- * Gemini history is `{ role, parts[] }`, where a part is a `functionCall`
- * (tool invocation) or `functionResponse` (its result). One model turn can
- * carry several `functionCall` parts and the following user turn carries the
- * matching `functionResponse` parts, so the CONTENT is the batch unit —
- * dropping a call turn together with its response turn can never orphan a part,
- * which Gemini rejects.
- */
-import type { GeminiGuardContent, LoopGuardPlan } from "../types/index.js";
-/** Marker left where dropped history used to be. */
-export declare const GEMINI_ELISION_NOTE = "[Earlier tool exchanges were removed to fit the context window.]";
-/** True when this content carries tool results worth previewing. */
-export declare function isGeminiToolResponseContent(content: GeminiGuardContent): boolean;
-/** Head/tail preview for an oversized tool response payload. */
-export declare function previewGeminiToolResponseText(text: string): string;
-/**
- * Decide what to reclaim from a Gemini agent loop.
- *
- * Returns `undefined` when the history still fits, in which case the caller
- * must leave it byte-identical — any rewrite invalidates the provider's cached
- * prefix, so "no change" has to mean no change.
- *
- * `observedPromptTokens` must be a count for the payload ABOUT TO BE SENT —
- * every Gemini-shaped loop plans only when its `createContextGuard` trips, and
- * that guard's `projectedNextPromptTokens` is exactly that: the provider's real
- * count for the last request plus the growth measured since. Dividing it by
- * this module's estimate of the current history therefore compares two views of
- * one payload, which is what makes the correction meaningful. A count for an
- * EARLIER request must not be passed here: the loop has appended a model turn
- * and its tool turn since, so the denominator would always be the larger of the
- * two, the ratio would read below 1 and the `Math.max(1, …)` floor would pin
- * calibration at 1 — silently disabling the correction. `planAnthropicLoopReclaim`
- * carries `previousSentEstimate` for callers in that other position.
- */
-export declare function planGeminiLoopReclaim(args: {
-    contents: readonly GeminiGuardContent[];
-    availableInputTokens: number;
-    fixedOverheadTokens?: number;
-    provider?: string;
-    observedPromptTokens?: number;
-}): LoopGuardPlan | undefined;

package/dist/lib/context/geminiLoopGuard.js

@@ -1,141 +0,0 @@
-/**
- * In-turn context guard for Gemini-shaped agent loops (native Vertex + AI
- * Studio + Gemini 3).
- *
- * These loops already had `createContextGuard`, but it is **stop-only**: once
- * the projected prompt crosses the threshold it breaks the loop and synthesizes
- * an answer from whatever it has. That avoids a provider rejection, but it also
- * ends the turn early — the model stops doing work it was mid-way through.
- *
- * This module brings them to parity with the other loops: reclaim budget and
- * CONTINUE, falling back to the existing stop only when reclaiming cannot get
- * back under the line. The reclaim policy is shared with every other provider
- * via `loopGuardCore`; this module owns only the Gemini shape mapping.
- *
- * Gemini history is `{ role, parts[] }`, where a part is a `functionCall`
- * (tool invocation) or `functionResponse` (its result). One model turn can
- * carry several `functionCall` parts and the following user turn carries the
- * matching `functionResponse` parts, so the CONTENT is the batch unit —
- * dropping a call turn together with its response turn can never orphan a part,
- * which Gemini rejects.
- */
-import { estimateTokens, TOKENS_PER_MESSAGE, } from "../utils/tokenEstimation.js";
-import { generateToolOutputPreview } from "./toolOutputLimits.js";
-import { planLoopGuardReclaim } from "./loopGuardCore.js";
-import { logger } from "../utils/logger.js";
-/** Preview budget for an old tool output. Matches the other loop guards. */
-const OLD_TOOL_OUTPUT_PREVIEW_BYTES = 2_048;
-const OLD_TOOL_OUTPUT_PREVIEW_LINES = 60;
-/** Marker left where dropped history used to be. */
-export const GEMINI_ELISION_NOTE = "[Earlier tool exchanges were removed to fit the context window.]";
-/** Serialize any value for estimation. Never throws. */
-function toText(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (value === null || value === undefined) {
-        return "";
-    }
-    try {
-        return JSON.stringify(value) ?? "";
-    }
-    catch {
-        // Past V8's string cap: enormous by definition, so charge a large fixed
-        // size rather than aborting the estimate and with it the turn.
-        return "x".repeat(200_000);
-    }
-}
-function hasPart(content, key) {
-    return (Array.isArray(content.parts) &&
-        content.parts.some((part) => part && typeof part === "object" && key in part));
-}
-/** True when this content carries tool results worth previewing. */
-export function isGeminiToolResponseContent(content) {
-    return hasPart(content, "functionResponse");
-}
-/** Head/tail preview for an oversized tool response payload. */
-export function previewGeminiToolResponseText(text) {
-    const { preview } = generateToolOutputPreview(text, {
-        maxBytes: OLD_TOOL_OUTPUT_PREVIEW_BYTES,
-        maxLines: OLD_TOOL_OUTPUT_PREVIEW_LINES,
-    });
-    return preview;
-}
-function contentTokens(content, provider) {
-    return estimateTokens(toText(content.parts), provider) + TOKENS_PER_MESSAGE;
-}
-/** Map Gemini history onto the neutral view the shared policy operates on. */
-function toEntries(contents, provider) {
-    return contents.map((content) => {
-        const tokens = contentTokens(content, provider);
-        if (isGeminiToolResponseContent(content)) {
-            // Only advertise a preview when it actually saves something: an
-            // already-small response must fall through to stage 2 rather than look
-            // shrinkable and stall the reclaim.
-            const previewed = toText(content.parts);
-            const previewTokens = previewed.length > OLD_TOOL_OUTPUT_PREVIEW_BYTES
-                ? estimateTokens(previewGeminiToolResponseText(previewed), provider) +
-                    TOKENS_PER_MESSAGE
-                : tokens;
-            return {
-                kind: "toolResult",
-                tokens,
-                ...(previewTokens < tokens ? { previewTokens } : {}),
-            };
-        }
-        if (hasPart(content, "functionCall")) {
-            return { kind: "toolCall", tokens };
-        }
-        return { kind: "other", tokens };
-    });
-}
-/**
- * Decide what to reclaim from a Gemini agent loop.
- *
- * Returns `undefined` when the history still fits, in which case the caller
- * must leave it byte-identical — any rewrite invalidates the provider's cached
- * prefix, so "no change" has to mean no change.
- *
- * `observedPromptTokens` must be a count for the payload ABOUT TO BE SENT —
- * every Gemini-shaped loop plans only when its `createContextGuard` trips, and
- * that guard's `projectedNextPromptTokens` is exactly that: the provider's real
- * count for the last request plus the growth measured since. Dividing it by
- * this module's estimate of the current history therefore compares two views of
- * one payload, which is what makes the correction meaningful. A count for an
- * EARLIER request must not be passed here: the loop has appended a model turn
- * and its tool turn since, so the denominator would always be the larger of the
- * two, the ratio would read below 1 and the `Math.max(1, …)` floor would pin
- * calibration at 1 — silently disabling the correction. `planAnthropicLoopReclaim`
- * carries `previousSentEstimate` for callers in that other position.
- */
-export function planGeminiLoopReclaim(args) {
-    const { contents, availableInputTokens, fixedOverheadTokens = 0, provider, observedPromptTokens, } = args;
-    const entries = toEntries(contents, provider);
-    let calibration = 1;
-    if (observedPromptTokens && observedPromptTokens > 0) {
-        const rawEstimate = fixedOverheadTokens + entries.reduce((sum, e) => sum + e.tokens, 0);
-        if (rawEstimate > 0) {
-            // Clamped: real tokenizers run up to ~1.3x the char estimate on dense
-            // code, and an unbounded ratio would compact the loop into uselessness.
-            calibration = Math.min(3, Math.max(1, observedPromptTokens / rawEstimate));
-        }
-    }
-    const plan = planLoopGuardReclaim(entries, {
-        availableInputTokens,
-        fixedOverheadTokens,
-        calibration,
-    });
-    if (!plan.fire) {
-        return undefined;
-    }
-    logger.info("[GeminiLoopGuard] Reclaiming agent-loop context", {
-        provider,
-        contents: contents.length,
-        toolResponsesTruncated: plan.truncate.length,
-        contentsDropped: plan.drop.length,
-        projectedTokens: plan.projectedTokens,
-        calibration,
-    });
-    return plan;
-}
-//# sourceMappingURL=geminiLoopGuard.js.map

package/dist/lib/context/loopGuardCore.d.ts

@@ -1,43 +0,0 @@
-/**
- * Provider-neutral agent-loop reclaim policy.
- *
- * Every native provider loop grows its own history as the model calls tools,
- * and every one of them can overflow the model's window mid-turn. The policy
- * for reclaiming that budget is identical regardless of message shape:
- *
- *   Stage 1 — shrink old tool outputs to head/tail previews.
- *   Stage 2 — drop the oldest complete tool batches, as units, when previews
- *             are not enough (or when outputs are already small enough that
- *             truncation buys nothing).
- *
- * What differs per provider is only the message SHAPE. So this module owns the
- * decision and adapters own the mechanics: map your history onto
- * `LoopGuardEntry[]`, call `planLoopGuardReclaim`, apply the returned indices.
- *
- * Two invariants the policy never violates:
- *   - entry 0 (the task) is never touched
- *   - a tool batch is dropped whole or not at all, so a `tool_call` never
- *     loses its `tool_result` (providers hard-reject the orphan)
- */
-import type { LoopGuardEntry, LoopGuardPlan, LoopGuardPolicy } from "../types/index.js";
-/**
- * Fraction of the window the guard reclaims DOWN TO once it fires.
- *
- * The threshold decides *when*; this decides *how far*. Reclaiming only back to
- * the threshold means the next step — which appends an assistant turn plus its
- * tool results — crosses it again, so the guard rewrites the oldest messages on
- * every single step. That mutation invalidates the provider's cached prompt
- * prefix each time. One deeper reclaim every N steps saves the same tokens and
- * leaves the prefix stable in between.
- */
-export declare const DEFAULT_LOOP_GUARD_LOW_WATER_RATIO = 0.6;
-/** Newest entries the guard never modifies. */
-export declare const DEFAULT_LOOP_GUARD_PROTECTED_TAIL = 4;
-/**
- * Decide what to reclaim, if anything.
- *
- * Returns `fire: false` when the projected request is within threshold — the
- * caller must then leave its history completely untouched, so a loop that fits
- * never pays a cache invalidation.
- */
-export declare function planLoopGuardReclaim(entries: readonly LoopGuardEntry[], policy: LoopGuardPolicy): LoopGuardPlan;