@juspay/neurolink 11.12.0 → 11.13.1

package/dist/lib/context/loopGuardCore.js

@@ -1,146 +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 { DEFAULT_CONTEXT_GUARD_RATIO } from "../core/constants.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 const DEFAULT_LOOP_GUARD_LOW_WATER_RATIO = 0.6;
-/** Newest entries the guard never modifies. */
-export const DEFAULT_LOOP_GUARD_PROTECTED_TAIL = 4;
-/** True for the two kinds that make up a tool batch. */
-function isToolEntry(entry) {
-    return entry?.kind === "toolCall" || entry?.kind === "toolResult";
-}
-/**
- * One agent step's tool batch: the run of calls, then the run of results that
- * answers them. `end` is exclusive.
- *
- * The boundary is calls-then-results, NOT any maximal run of tool entries — a
- * loop's history is `call,result,call,result,…`, so treating a maximal run as
- * one batch would collapse the entire conversation into a single droppable
- * unit and scorch it in one pass. Mirrors `collectBatch` in toolPairRepair.
- */
-function findToolBatches(entries, minIndex, maxIndexExclusive) {
-    const batches = [];
-    let i = minIndex;
-    while (i < maxIndexExclusive) {
-        if (!isToolEntry(entries[i])) {
-            i++;
-            continue;
-        }
-        const start = i;
-        // Scan each run to its TRUE end rather than clamping at the protected-tail
-        // boundary. A batch is droppable only as a whole: clamping would emit a
-        // batch ending exactly at the boundary, so stage 2 would remove the
-        // tool-call entry while the results at or past the boundary survive with
-        // nothing to pair against. Providers reject an orphaned tool result, so
-        // that turns a reclaim into a hard request failure.
-        while (i < entries.length && entries[i].kind === "toolCall") {
-            i++;
-        }
-        while (i < entries.length && entries[i].kind === "toolResult") {
-            i++;
-        }
-        if (i > maxIndexExclusive) {
-            // Scanning is oldest-first, so this batch reaching into the tail means
-            // every later one starts inside it. Nothing further is droppable.
-            break;
-        }
-        batches.push({ start, end: i });
-    }
-    return batches;
-}
-/**
- * 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 function planLoopGuardReclaim(entries, policy) {
-    const { availableInputTokens, fixedOverheadTokens, thresholdRatio = DEFAULT_CONTEXT_GUARD_RATIO, lowWaterRatio = DEFAULT_LOOP_GUARD_LOW_WATER_RATIO, protectedTailCount = DEFAULT_LOOP_GUARD_PROTECTED_TAIL, calibration = 1, } = policy;
-    const safeCalibration = calibration > 0 ? calibration : 1;
-    const thresholdTokens = Math.floor((availableInputTokens * thresholdRatio) / safeCalibration);
-    const lowWaterTokens = Math.floor((availableInputTokens * lowWaterRatio) / safeCalibration);
-    let total = fixedOverheadTokens;
-    for (const entry of entries) {
-        total += entry.tokens;
-    }
-    if (total <= thresholdTokens) {
-        return { fire: false, truncate: [], drop: [], projectedTokens: total };
-    }
-    // Entry 0 is the task and the newest `protectedTailCount` entries are the
-    // live working set — the mutable window sits strictly between them.
-    const minIndex = 1;
-    const maxIndexExclusive = Math.max(minIndex, entries.length - protectedTailCount);
-    const truncate = [];
-    const dropped = new Set();
-    // Stage 1: shrink old tool outputs, oldest first.
-    for (let i = minIndex; i < maxIndexExclusive && total > lowWaterTokens; i++) {
-        const entry = entries[i];
-        if (entry.kind !== "toolResult" || entry.previewTokens === undefined) {
-            continue;
-        }
-        const saving = entry.tokens - entry.previewTokens;
-        if (saving <= 0) {
-            continue;
-        }
-        truncate.push(i);
-        total -= saving;
-    }
-    // Stage 2: drop whole batches, oldest first, while still over the low-water
-    // mark. This is the only lever when outputs are already smaller than a
-    // preview — the regime where truncation alone cannot converge.
-    if (total > lowWaterTokens) {
-        const batches = findToolBatches(entries, minIndex, maxIndexExclusive);
-        for (const batch of batches) {
-            if (total <= lowWaterTokens) {
-                break;
-            }
-            for (let i = batch.start; i < batch.end; i++) {
-                const entry = entries[i];
-                // A truncated entry now costs its preview, not its original payload.
-                const effective = truncate.includes(i)
-                    ? (entry.previewTokens ?? entry.tokens)
-                    : entry.tokens;
-                total -= effective;
-                dropped.add(i);
-            }
-        }
-    }
-    // Truncating an entry that is being dropped anyway is wasted work.
-    const effectiveTruncate = truncate.filter((i) => !dropped.has(i));
-    return {
-        fire: effectiveTruncate.length > 0 || dropped.size > 0,
-        truncate: effectiveTruncate,
-        drop: [...dropped].sort((a, b) => a - b),
-        projectedTokens: total,
-    };
-}
-//# sourceMappingURL=loopGuardCore.js.map

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

@@ -1,42 +0,0 @@
-/**
- * In-turn context guard for the OpenAI-compatible chat-completions loop.
- *
- * `openaiChatCompletionsBase` runs its own hand-written tool loop
- * (`for step < maxSteps` → `streamOneStep` → `executeToolBatch`) and appends an
- * assistant tool-call message plus one `role: "tool"` message per result on
- * every step. Nothing bounded that growth: the loop had no context guard of any
- * kind, so a long agentic run walked into a provider "context length exceeded"
- * after dozens of tool calls and lost every completed step.
- *
- * This is the widest-reach gap in the codebase — the chat-completions base
- * backs LiteLLM, DeepSeek, OpenRouter, NVIDIA NIM, LM Studio, llama.cpp and
- * every `openai-compatible` provider.
- *
- * The reclaim POLICY lives in `loopGuardCore` and is shared with the other
- * provider loops. This module owns only the shape mapping: OpenAI-compatible
- * messages in, neutral entries out, plan applied back.
- */
-import type { OpenAICompatChatMessage } from "../types/index.js";
-/**
- * Reclaim context budget from a chat-completions loop's conversation.
- *
- * Returns a NEW array when it acted, or `undefined` when the loop fits and the
- * history must be left byte-identical — any rewrite invalidates the provider's
- * cached prompt prefix, so "no change" has to mean no change.
- *
- * @param observedPromptTokens the provider's reported prompt token count for
- * the previous step, used to calibrate the char-based estimate for free.
- * @param previousSentEstimate this guard's own estimate for the request that
- * produced `observedPromptTokens`. The two must describe the SAME request.
- * @param onSentEstimate receives the estimate for the request about to be sent,
- * so the caller can feed it back as the next step's `previousSentEstimate`.
- */
-export declare function guardOpenAICompatConversation(args: {
-    conversation: OpenAICompatChatMessage[];
-    availableInputTokens: number;
-    fixedOverheadTokens: number;
-    provider?: string;
-    observedPromptTokens?: number;
-    previousSentEstimate?: number;
-    onSentEstimate?: (tokens: number) => void;
-}): OpenAICompatChatMessage[] | undefined;

package/dist/lib/context/openaiCompatLoopGuard.js

@@ -1,173 +0,0 @@
-/**
- * In-turn context guard for the OpenAI-compatible chat-completions loop.
- *
- * `openaiChatCompletionsBase` runs its own hand-written tool loop
- * (`for step < maxSteps` → `streamOneStep` → `executeToolBatch`) and appends an
- * assistant tool-call message plus one `role: "tool"` message per result on
- * every step. Nothing bounded that growth: the loop had no context guard of any
- * kind, so a long agentic run walked into a provider "context length exceeded"
- * after dozens of tool calls and lost every completed step.
- *
- * This is the widest-reach gap in the codebase — the chat-completions base
- * backs LiteLLM, DeepSeek, OpenRouter, NVIDIA NIM, LM Studio, llama.cpp and
- * every `openai-compatible` provider.
- *
- * The reclaim POLICY lives in `loopGuardCore` and is shared with the other
- * provider loops. This module owns only the shape mapping: OpenAI-compatible
- * messages in, neutral entries out, plan applied back.
- */
-import { estimateTokens, TOKENS_PER_MESSAGE, } from "../utils/tokenEstimation.js";
-import { exceedsToolOutputPreviewBudget, generateToolOutputPreview, } from "./toolOutputLimits.js";
-import { planLoopGuardReclaim } from "./loopGuardCore.js";
-import { logger } from "../utils/logger.js";
-/** Preview budget for an old tool output. Matches the AI-SDK guard. */
-const OLD_TOOL_OUTPUT_PREVIEW_BYTES = 2_048;
-const OLD_TOOL_OUTPUT_PREVIEW_LINES = 60;
-/** Marker left where dropped history used to be. */
-const ELISION_NOTE = "[Earlier tool exchanges were removed to fit the context window.]";
-/** Serialize message content to text for estimation. Never throws. */
-function contentToText(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    if (content === null || content === undefined) {
-        return "";
-    }
-    try {
-        return JSON.stringify(content) ?? "";
-    }
-    catch {
-        // A payload past V8's string cap is enormous by definition; charge it a
-        // large fixed size rather than aborting the estimate and the turn.
-        return "x".repeat(200_000);
-    }
-}
-/** Cost of one message, including per-message framing. */
-function messageTokens(message, provider) {
-    let text = contentToText(message.content);
-    if (message.role === "assistant" && message.tool_calls) {
-        // Tool-call arguments are a first-class cost here: the model's arguments
-        // for a Write/Edit-style tool dwarf the message body.
-        text += contentToText(message.tool_calls);
-    }
-    return estimateTokens(text, provider) + TOKENS_PER_MESSAGE;
-}
-/** Preview cost of a `role: "tool"` message, or undefined when it cannot shrink. */
-function previewTokensFor(message, provider) {
-    if (message.role !== "tool") {
-        return undefined;
-    }
-    const text = contentToText(message.content);
-    const previewOptions = {
-        maxBytes: OLD_TOOL_OUTPUT_PREVIEW_BYTES,
-        maxLines: OLD_TOOL_OUTPUT_PREVIEW_LINES,
-    };
-    if (!exceedsToolOutputPreviewBudget(text, previewOptions)) {
-        return undefined;
-    }
-    const { preview } = generateToolOutputPreview(text, previewOptions);
-    return estimateTokens(preview, provider) + TOKENS_PER_MESSAGE;
-}
-/** Map the loop's history onto the neutral view the policy operates on. */
-function toEntries(conversation, provider) {
-    return conversation.map((message) => {
-        const tokens = messageTokens(message, provider);
-        if (message.role === "tool") {
-            const previewTokens = previewTokensFor(message, provider);
-            return {
-                kind: "toolResult",
-                tokens,
-                ...(previewTokens !== undefined ? { previewTokens } : {}),
-            };
-        }
-        if (message.role === "assistant" && message.tool_calls?.length) {
-            return { kind: "toolCall", tokens };
-        }
-        return { kind: "other", tokens };
-    });
-}
-/**
- * Reclaim context budget from a chat-completions loop's conversation.
- *
- * Returns a NEW array when it acted, or `undefined` when the loop fits and the
- * history must be left byte-identical — any rewrite invalidates the provider's
- * cached prompt prefix, so "no change" has to mean no change.
- *
- * @param observedPromptTokens the provider's reported prompt token count for
- * the previous step, used to calibrate the char-based estimate for free.
- * @param previousSentEstimate this guard's own estimate for the request that
- * produced `observedPromptTokens`. The two must describe the SAME request.
- * @param onSentEstimate receives the estimate for the request about to be sent,
- * so the caller can feed it back as the next step's `previousSentEstimate`.
- */
-export function guardOpenAICompatConversation(args) {
-    const { conversation, availableInputTokens, fixedOverheadTokens, provider, observedPromptTokens, previousSentEstimate, onSentEstimate, } = args;
-    const entries = toEntries(conversation, provider);
-    const rawEstimate = fixedOverheadTokens + entries.reduce((sum, e) => sum + e.tokens, 0);
-    // Calibration compares a real prompt-token count against THIS guard's
-    // estimate for the very request that produced it. Dividing by the estimate
-    // for the CURRENT conversation would be a category error: the loop has since
-    // appended an assistant tool-call message plus its results, so the
-    // denominator is always larger than the numerator's request. The ratio then
-    // reads below 1 and the `Math.max(1, …)` floor pins calibration at 1 — the
-    // correction silently never applies, which is exactly when a dense-code run
-    // overflows the window.
-    let calibration = 1;
-    if (observedPromptTokens &&
-        observedPromptTokens > 0 &&
-        previousSentEstimate &&
-        previousSentEstimate > 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 / previousSentEstimate));
-    }
-    const plan = planLoopGuardReclaim(entries, {
-        availableInputTokens,
-        fixedOverheadTokens,
-        calibration,
-    });
-    if (!plan.fire) {
-        onSentEstimate?.(rawEstimate);
-        return undefined;
-    }
-    const truncateSet = new Set(plan.truncate);
-    const dropSet = new Set(plan.drop);
-    const result = [];
-    for (let i = 0; i < conversation.length; i++) {
-        if (dropSet.has(i)) {
-            continue;
-        }
-        const message = conversation[i];
-        if (truncateSet.has(i) && message.role === "tool") {
-            const { preview } = generateToolOutputPreview(contentToText(message.content), {
-                maxBytes: OLD_TOOL_OUTPUT_PREVIEW_BYTES,
-                maxLines: OLD_TOOL_OUTPUT_PREVIEW_LINES,
-            });
-            result.push({ ...message, content: preview });
-            continue;
-        }
-        result.push(message);
-    }
-    if (dropSet.size > 0) {
-        // Place the note where the removed history was, i.e. before the first
-        // surviving tool message — never at the end, where a "history was removed"
-        // cue would land after the content it refers to.
-        let noteIndex = result.findIndex((m) => m.role === "tool" || (m.role === "assistant" && m.tool_calls));
-        if (noteIndex < 0) {
-            noteIndex = Math.min(1, result.length);
-        }
-        result.splice(noteIndex, 0, { role: "user", content: ELISION_NOTE });
-    }
-    logger.info("[OpenAICompatLoopGuard] Reclaimed agent-loop context", {
-        provider,
-        messagesBefore: conversation.length,
-        messagesAfter: result.length,
-        toolOutputsTruncated: plan.truncate.length,
-        messagesDropped: plan.drop.length,
-        projectedTokens: plan.projectedTokens,
-        calibration,
-    });
-    onSentEstimate?.(plan.projectedTokens);
-    return result;
-}
-//# sourceMappingURL=openaiCompatLoopGuard.js.map

package/dist/lib/context/prompts/summarizationPrompt.d.ts

@@ -1,16 +0,0 @@
-/**
- * Summarization Prompt Builder
- *
- * Builds prompts for summarizing conversation context into a 10-section structure.
- * Supports both initial summarization and incremental merging with existing summaries.
- */
-import type { SummarizationPromptOptions } from "../../types/index.js";
-declare const SUMMARY_SECTIONS: string[];
-/**
- * Builds a summarization prompt based on the provided options.
- *
- * @param options - Configuration for the prompt builder
- * @returns The constructed prompt string
- */
-export declare function buildSummarizationPrompt(options: SummarizationPromptOptions): string;
-export { SUMMARY_SECTIONS };

package/dist/lib/context/prompts/summarizationPrompt.js

@@ -1,118 +0,0 @@
-/**
- * Summarization Prompt Builder
- *
- * Builds prompts for summarizing conversation context into a 10-section structure.
- * Supports both initial summarization and incremental merging with existing summaries.
- */
-const SUMMARY_SECTIONS = [
-    "Primary Request and Intent",
-    "Key Technical Concepts",
-    "Files and Code Sections",
-    "Problem Solving",
-    "Pending Tasks",
-    "Task Evolution",
-    "Current Work",
-    "Next Step",
-    "Required Files",
-    "Constraints and Established Rules",
-];
-function buildFileContextSection(filesRead, filesModified) {
-    const hasFiles = (filesRead && filesRead.length > 0) ||
-        (filesModified && filesModified.length > 0);
-    if (!hasFiles) {
-        return "";
-    }
-    let section = "\n\nFile Context:\n";
-    if (filesRead && filesRead.length > 0) {
-        section += "Files Read:\n";
-        for (const file of filesRead) {
-            section += `- ${file}\n`;
-        }
-    }
-    if (filesModified && filesModified.length > 0) {
-        section += "Files Modified:\n";
-        for (const file of filesModified) {
-            section += `- ${file}\n`;
-        }
-    }
-    return section;
-}
-function buildInitialPrompt(options) {
-    const fileContext = buildFileContextSection(options.filesRead, options.filesModified);
-    return `You are a context summarization assistant. Your task is to analyze the conversation and create a structured summary following a 10-section format.
-
-Create a summary with the following sections:
-
-### 1. Primary Request and Intent
-What is the user's main goal or request? What are they trying to accomplish?
-
-### 2. Key Technical Concepts
-What technologies, frameworks, patterns, or concepts are central to this conversation?
-
-### 3. Files and Code Sections
-What specific files, functions, or code sections have been discussed or modified?
-
-### 4. Problem Solving
-What problems were identified? What solutions were attempted or implemented?
-
-### 5. Pending Tasks
-What tasks remain incomplete or need follow-up?
-
-### 6. Task Evolution
-How has the task changed or evolved during the conversation?
-
-### 7. Current Work
-What is being actively worked on right now?
-
-### 8. Next Step
-What is the immediate next action to take?
-
-### 9. Required Files
-What files will need to be accessed or modified to continue?
-
-### 10. Constraints and Established Rules
-What user-imposed constraints, behavioral directives, coding standards, agreed-upon decisions, or established rules must persist across the conversation? Include any "always do X", "never do Y", naming conventions, architectural patterns, or preferences the user has stated.${fileContext}
-
-IMPORTANT: Section 10 (Constraints and Established Rules) must ALWAYS be preserved in full. User constraints and established agreements are never "no longer relevant" — they remain in effect for the entire session unless the user explicitly revokes them.
-
-Analyze the conversation thoroughly and fill in each section with relevant information. If a section is not applicable, write "N/A" for that section.`;
-}
-function buildIncrementalPrompt(options) {
-    const fileContext = buildFileContextSection(options.filesRead, options.filesModified);
-    return `You are a context summarization assistant. Your task is to MERGE new conversation content with an existing summary.
-
-Existing Summary:
----
-${options.previousSummary}
----
-
-Update sections with new information while preserving important context from the existing summary. Maintain the same 10-section structure.
-
-Instructions:
-1. Review the existing summary above
-2. Analyze the new conversation content
-3. MERGE the new information into the appropriate sections
-4. Update sections with relevant new information
-5. Remove information that is no longer relevant EXCEPT for Section 10 (Constraints and Established Rules) — user constraints and established agreements must ALWAYS be preserved unless the user explicitly revoked them
-6. Keep the summary concise but comprehensive
-7. Maintain the 10-section format
-8. Always carry forward ALL entries from Section 10 of the existing summary, adding any new constraints found in the new content${fileContext}
-
-Output the updated summary following the same 10-section structure.`;
-}
-/**
- * Builds a summarization prompt based on the provided options.
- *
- * @param options - Configuration for the prompt builder
- * @returns The constructed prompt string
- */
-export function buildSummarizationPrompt(options) {
-    // For incremental mode, we need a previous summary to merge with
-    // If no previous summary is provided, fall back to initial prompt
-    if (options.isIncremental && options.previousSummary) {
-        return buildIncrementalPrompt(options);
-    }
-    return buildInitialPrompt(options);
-}
-export { SUMMARY_SECTIONS };
-//# sourceMappingURL=summarizationPrompt.js.map

package/dist/lib/context/stages/fileReadDeduplicator.d.ts

@@ -1,8 +0,0 @@
-/**
- * Stage 2: File Read Deduplication
- *
- * Detect multiple reads of the same file path, keep only the latest,
- * replace earlier reads with a notice.
- */
-import type { ChatMessage, DeduplicationResult } from "../../types/index.js";
-export declare function deduplicateFileReads(messages: ChatMessage[]): DeduplicationResult;

package/dist/lib/context/stages/fileReadDeduplicator.js

@@ -1,67 +0,0 @@
-/**
- * Stage 2: File Read Deduplication
- *
- * Detect multiple reads of the same file path, keep only the latest,
- * replace earlier reads with a notice.
- */
-const FILE_READ_PATTERN = /(?:read|reading|read_file|readFile|Read file|cat)\s+['"`]?([^\s'"`\n]+)/i;
-const DEDUP_NOTICE = (filePath) => `[File ${filePath} - refer to latest read below]`;
-const DEDUP_THRESHOLD = 0.3; // Need 30% savings to declare success
-export function deduplicateFileReads(messages) {
-    // Track file read positions: filePath -> array of message indices
-    const fileReadMap = new Map();
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role !== "tool_result" && msg.role !== "assistant") {
-            continue;
-        }
-        const match = msg.content.match(FILE_READ_PATTERN);
-        if (match) {
-            const filePath = match[1];
-            const existing = fileReadMap.get(filePath) || [];
-            existing.push(i);
-            fileReadMap.set(filePath, existing);
-        }
-    }
-    // Find files read multiple times
-    const duplicates = new Map();
-    for (const [filePath, indices] of fileReadMap) {
-        if (indices.length > 1) {
-            duplicates.set(filePath, indices);
-        }
-    }
-    if (duplicates.size === 0) {
-        return { deduplicated: false, messages, filesDeduped: 0 };
-    }
-    const result = [...messages];
-    let totalOriginalChars = 0;
-    let totalReplacedChars = 0;
-    for (const [filePath, indices] of duplicates) {
-        // Keep the latest (last index), replace all earlier ones
-        const latestIndex = indices[indices.length - 1];
-        for (const idx of indices) {
-            if (idx === latestIndex) {
-                continue;
-            }
-            const original = result[idx];
-            totalOriginalChars += original.content.length;
-            const notice = DEDUP_NOTICE(filePath);
-            totalReplacedChars += notice.length;
-            result[idx] = {
-                ...original,
-                content: notice,
-                metadata: { ...original.metadata, truncated: true },
-            };
-        }
-    }
-    const savings = totalOriginalChars > 0
-        ? (totalOriginalChars - totalReplacedChars) / totalOriginalChars
-        : 0;
-    const deduplicated = savings >= DEDUP_THRESHOLD;
-    return {
-        deduplicated,
-        messages: deduplicated ? result : messages,
-        filesDeduped: deduplicated ? duplicates.size : 0,
-    };
-}
-//# sourceMappingURL=fileReadDeduplicator.js.map

package/dist/lib/context/stages/slidingWindowTruncator.d.ts

@@ -1,15 +0,0 @@
-/**
- * Stage 4: Sliding Window Truncation
- *
- * Non-destructive fallback: tags oldest messages as truncated
- * instead of deleting them. Always preserves first message pair.
- * Removes messages in pairs to maintain role alternation.
- *
- * Features:
- * - Adaptive truncation (PERF-001): calculates fraction from actual overage
- *   instead of fixed 50%, with iterative refinement up to 6 passes.
- * - Small conversation handling (BUG-005): for <= 4 messages, truncates
- *   message content proportionally instead of returning no-op.
- */
-import type { ChatMessage, TruncationConfig, TruncationResult } from "../../types/index.js";
-export declare function truncateWithSlidingWindow(messages: ChatMessage[], config?: TruncationConfig): TruncationResult;