@juspay/neurolink 11.13.0 → 11.13.2

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

@@ -1,237 +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 { estimateTokens, estimateMessagesTokens, truncateToTokenBudget, } from "../../utils/tokenEstimation.js";
-import { logger } from "../../utils/logger.js";
-import { randomUUID } from "crypto";
-const TRUNCATION_MARKER_CONTENT = "[Earlier conversation history was truncated to fit within context limits]";
-function validateRoleAlternation(messages) {
-    for (let i = 1; i < messages.length; i++) {
-        if (messages[i].role === messages[i - 1].role &&
-            messages[i].role !== "system") {
-            logger.warn(`[SlidingWindowTruncator] Role alternation broken at index ${i}: consecutive "${messages[i].role}" messages`);
-        }
-    }
-}
-/**
- * For conversations with <= 4 messages that exceed token budget,
- * truncate the CONTENT of the longest messages rather than removing messages.
- *
- * Strategy:
- * 1. Calculate each message's proportional share of the token budget
- * 2. Truncate messages that exceed their share using truncateToTokenBudget()
- * 3. Never truncate messages below 200 tokens (preserve minimum context)
- */
-function truncateSmallConversation(messages, config) {
-    // If no target tokens provided, we can't do content truncation
-    if (!config?.targetTokens) {
-        return { truncated: false, messages, messagesRemoved: 0 };
-    }
-    const provider = config.provider;
-    const targetTokens = config.targetTokens;
-    const currentTokens = estimateMessagesTokens(messages, provider);
-    if (currentTokens <= targetTokens) {
-        return { truncated: false, messages, messagesRemoved: 0 };
-    }
-    const MINIMUM_MSG_TOKENS = 200;
-    const FRAMING_OVERHEAD = 24 + messages.length * 4; // conversation + per-message overhead
-    // Available budget for actual content
-    const contentBudget = targetTokens - FRAMING_OVERHEAD;
-    if (contentBudget <= 0) {
-        return { truncated: false, messages, messagesRemoved: 0 };
-    }
-    // Calculate current content tokens per message
-    const msgTokens = messages.map((msg) => estimateTokens(msg.content, provider));
-    const totalContentTokens = msgTokens.reduce((sum, t) => sum + t, 0);
-    // Each message gets a proportional share of the content budget
-    const result = [...messages];
-    let totalSaved = 0;
-    for (let i = 0; i < result.length; i++) {
-        const msg = result[i];
-        // Don't truncate system/summary messages or pinned skill instructions
-        if (msg.role === "system" ||
-            msg.metadata?.isSummary ||
-            msg.metadata?.isSkill) {
-            continue;
-        }
-        const proportionalBudget = Math.floor((msgTokens[i] / totalContentTokens) * contentBudget);
-        const msgBudget = Math.max(MINIMUM_MSG_TOKENS, proportionalBudget);
-        if (msgTokens[i] > msgBudget) {
-            const truncated = truncateToTokenBudget(msg.content, msgBudget, provider);
-            if (truncated.truncated) {
-                totalSaved += msgTokens[i] - estimateTokens(truncated.text, provider);
-                result[i] = {
-                    ...msg,
-                    content: truncated.text,
-                    metadata: { ...msg.metadata, truncated: true },
-                };
-            }
-        }
-    }
-    if (totalSaved > 0) {
-        const finalTokens = estimateMessagesTokens(result, provider);
-        logger.info("[Truncation] Small conversation content truncated", {
-            messageCount: messages.length,
-            tokensSaved: totalSaved,
-            targetTokens,
-            finalTokens,
-        });
-        return {
-            truncated: finalTokens <= targetTokens,
-            messages: result,
-            messagesRemoved: 0, // No messages removed, only content truncated
-        };
-    }
-    return { truncated: false, messages, messagesRemoved: 0 };
-}
-export function truncateWithSlidingWindow(messages, config) {
-    // Partition pinned skill messages out so the pair-based arithmetic below
-    // runs on the alternating user/assistant stream (skill pins are extra
-    // user-role messages inside a turn and would misalign every even-count
-    // cut). Each skill anchors to the next conversational message; kept
-    // anchors put their skills back in place, dropped anchors re-seat them
-    // after the truncation marker.
-    const skillsByAnchor = new Map();
-    const trailingSkills = [];
-    const conversational = [];
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (!msg.metadata?.isSkill) {
-            conversational.push(msg);
-            continue;
-        }
-        const anchor = messages
-            .slice(i + 1)
-            .find((next) => !next.metadata?.isSkill);
-        if (anchor) {
-            const anchored = skillsByAnchor.get(anchor.id);
-            if (anchored) {
-                anchored.push(msg);
-            }
-            else {
-                skillsByAnchor.set(anchor.id, [msg]);
-            }
-        }
-        else {
-            trailingSkills.push(msg);
-        }
-    }
-    if (conversational.length <= 4) {
-        // Delegate to content truncation for small conversations (BUG-005);
-        // it never removes messages, so skills keep their positions.
-        return truncateSmallConversation(messages, config);
-    }
-    // ADAPTIVE MODE: calculate fraction from actual overage (PERF-001)
-    let fraction;
-    if (config?.currentTokens &&
-        config?.targetTokens &&
-        config.currentTokens > config.targetTokens) {
-        const overageRatio = (config.currentTokens - config.targetTokens) / config.currentTokens;
-        const buffer = config?.adaptiveBuffer ?? 0.15;
-        // Required fraction = overage ratio + buffer, clamped to [0.1, 0.9]
-        fraction = Math.min(0.9, Math.max(0.1, overageRatio + buffer));
-        logger.info("[Truncation] Adaptive fraction calculated", {
-            currentTokens: config.currentTokens,
-            targetTokens: config.targetTokens,
-            overageRatio: Math.round(overageRatio * 100),
-            fraction: Math.round(fraction * 100),
-        });
-    }
-    else {
-        // Fallback to configured or default fraction
-        fraction = config?.fraction ?? 0.5;
-    }
-    // Always preserve first user-assistant pair
-    const firstPair = conversational.slice(0, 2);
-    const remainingMessages = conversational.slice(2);
-    /** Reassemble a candidate: skills inline before kept anchors, orphans after the marker. */
-    const buildCandidate = (keptAfterTruncation, marker) => {
-        const keptIds = new Set([...firstPair, ...keptAfterTruncation].map((m) => m.id));
-        const orphanedSkills = [];
-        for (const [anchorId, anchored] of skillsByAnchor) {
-            if (!keptIds.has(anchorId)) {
-                orphanedSkills.push(...anchored);
-            }
-        }
-        const withInlineSkills = (msg) => {
-            const anchored = skillsByAnchor.get(msg.id);
-            return anchored ? [...anchored, msg] : [msg];
-        };
-        return [
-            ...firstPair.flatMap(withInlineSkills),
-            marker,
-            ...orphanedSkills,
-            ...keptAfterTruncation.flatMap(withInlineSkills),
-            ...trailingSkills,
-        ];
-    };
-    // Insert a truncation marker with machine-readable metadata so
-    // effectiveHistory.ts can detect it via isTruncationMarker /
-    // truncationId and removeTruncationTags can rewind it.
-    const makeMarker = () => {
-        const truncId = randomUUID();
-        return {
-            id: `truncation-marker-${truncId}`,
-            role: "user",
-            content: TRUNCATION_MARKER_CONTENT,
-            isTruncationMarker: true,
-            truncationId: truncId,
-        };
-    };
-    // ITERATIVE: if first pass isn't enough, increase fraction
-    const maxIterations = config?.maxIterations ?? 3;
-    let currentFraction = fraction;
-    for (let iteration = 0; iteration < maxIterations; iteration++) {
-        const removeCount = Math.floor(remainingMessages.length * currentFraction);
-        const evenRemoveCount = removeCount - (removeCount % 2);
-        if (evenRemoveCount <= 0) {
-            break;
-        }
-        const candidateMessages = buildCandidate(remainingMessages.slice(evenRemoveCount), makeMarker());
-        validateRoleAlternation(candidateMessages);
-        // If we have token targets, verify the result fits
-        if (config?.targetTokens) {
-            const candidateTokens = estimateMessagesTokens(candidateMessages, config.provider);
-            if (candidateTokens <= config.targetTokens) {
-                return {
-                    truncated: true,
-                    messages: candidateMessages,
-                    messagesRemoved: evenRemoveCount,
-                };
-            }
-            // Not enough -- increase fraction by 10% for finer-grained escalation
-            currentFraction = Math.min(0.95, currentFraction + 0.1);
-            continue;
-        }
-        // No token targets -- single-pass with calculated fraction
-        return {
-            truncated: true,
-            messages: candidateMessages,
-            messagesRemoved: evenRemoveCount,
-        };
-    }
-    // All iterations exhausted -- return best effort (most aggressive truncation)
-    const maxRemove = Math.floor(remainingMessages.length * 0.95);
-    const evenMaxRemove = maxRemove - (maxRemove % 2);
-    if (evenMaxRemove > 0) {
-        const fallbackMessages = buildCandidate(remainingMessages.slice(evenMaxRemove), makeMarker());
-        validateRoleAlternation(fallbackMessages);
-        return {
-            truncated: true,
-            messages: fallbackMessages,
-            messagesRemoved: evenMaxRemove,
-        };
-    }
-    return { truncated: false, messages, messagesRemoved: 0 };
-}
-//# sourceMappingURL=slidingWindowTruncator.js.map

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

@@ -1,8 +0,0 @@
-/**
- * Stage 3: Structured LLM Summarization
- *
- * Uses the structured 10-section prompt to summarize older messages
- * while preserving recent ones.
- */
-import type { SummarizeConfig, SummarizeResult, ChatMessage } from "../../types/index.js";
-export declare function summarizeMessages(messages: ChatMessage[], config?: SummarizeConfig): Promise<SummarizeResult>;

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

@@ -1,123 +0,0 @@
-/**
- * Stage 3: Structured LLM Summarization
- *
- * Uses the structured 10-section prompt to summarize older messages
- * while preserving recent ones.
- */
-import { randomUUID } from "crypto";
-import { generateSummary } from "../../utils/conversationMemory.js";
-import { estimateTokens } from "../../utils/tokenEstimation.js";
-import { logger } from "../../utils/logger.js";
-import { snapSplitToBatchBoundary } from "../toolPairRepair.js";
-/**
- * Find the split index using token counting — walk backward from the end,
- * accumulating token counts until we've reserved `targetRecentTokens` worth
- * of recent content. Everything before the split index gets summarized.
- */
-function findSplitIndexByTokens(messages, targetRecentTokens, provider) {
-    let recentTokens = 0;
-    let splitIndex = messages.length;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        // Guarded: JSON.stringify on a giant single message can throw RangeError
-        // (V8 max string length). A message that big cannot be "recent-window"
-        // material anyway — treat it as effectively infinite tokens so it (and
-        // everything older) lands on the summarized side instead of aborting
-        // compaction.
-        let msgTokens;
-        try {
-            const content = typeof messages[i].content === "string"
-                ? messages[i].content
-                : (JSON.stringify(messages[i].content) ?? "");
-            msgTokens = estimateTokens(content, provider);
-        }
-        catch {
-            msgTokens = Number.MAX_SAFE_INTEGER;
-        }
-        if (recentTokens + msgTokens > targetRecentTokens) {
-            splitIndex = i + 1;
-            break;
-        }
-        recentTokens += msgTokens;
-    }
-    // Ensure at least one message is summarized, then snap off any tool batch
-    // the boundary would otherwise cut in half — a summary that starts the
-    // recent window on an orphaned tool_result is rejected by the provider.
-    return snapSplitToBatchBoundary(messages, Math.max(1, splitIndex));
-}
-export async function summarizeMessages(messages, config) {
-    const keepRecentRatio = config?.keepRecentRatio ?? 0.3;
-    if (messages.length <= 4) {
-        return { summarized: false, messages };
-    }
-    // Determine split point: prefer token-based when a target budget is available,
-    // fall back to message-count-based split for backward compatibility.
-    let splitIndex;
-    if (config?.targetTokens && config.targetTokens > 0) {
-        // Keep `keepRecentRatio` fraction of the target budget as recent context
-        const targetRecentTokens = Math.floor(config.targetTokens * keepRecentRatio);
-        // NOTE: config.provider is the summarization provider, not the generation
-        // provider. Ideally we'd use the generation/budget provider for accurate
-        // token estimation, but SummarizeConfig doesn't carry a separate
-        // budgetProvider field. This is a known design limitation.
-        splitIndex = findSplitIndexByTokens(messages, targetRecentTokens, config.provider);
-    }
-    else {
-        // Legacy: message-count-based split
-        const keepCount = Math.max(4, Math.ceil(messages.length * keepRecentRatio));
-        splitIndex = messages.length - keepCount;
-    }
-    // Clamp so at least the last message is always preserved (never summarize everything)
-    splitIndex = Math.min(splitIndex, messages.length - 1);
-    // Re-snap AFTER the clamp: the clamp can pull the boundary back into a tool
-    // batch that findSplitIndexByTokens had already cleared, and it is also the
-    // only guard covering the legacy message-count branch above.
-    splitIndex = snapSplitToBatchBoundary(messages, splitIndex);
-    // A boundary that still cuts a batch means no legal split exists (e.g. the
-    // whole array is one tool batch). Summarizing anyway would hand the provider
-    // an orphaned tool_result, so decline and let a later stage reclaim instead.
-    if (splitIndex <= 0 ||
-        splitIndex >= messages.length ||
-        splitIndex !== snapSplitToBatchBoundary(messages, splitIndex)) {
-        return { summarized: false, messages };
-    }
-    const messagesToSummarize = messages.slice(0, splitIndex);
-    const recentMessages = messages.slice(splitIndex);
-    // Find previous summary if exists
-    const previousSummary = messagesToSummarize.find((m) => m.metadata?.isSummary)?.content;
-    // Build effective memory config: use provided memoryConfig, or construct from provider/model
-    const effectiveMemoryConfig = config?.memoryConfig ? { ...config.memoryConfig } : {};
-    // Fill in summarization provider/model from compactor config if not already set
-    if (!effectiveMemoryConfig.summarizationProvider && config?.provider) {
-        effectiveMemoryConfig.summarizationProvider = config.provider;
-    }
-    if (!effectiveMemoryConfig.summarizationModel && config?.model) {
-        effectiveMemoryConfig.summarizationModel = config.model;
-    }
-    // Only skip if there's genuinely no provider available
-    if (!effectiveMemoryConfig.summarizationProvider &&
-        !effectiveMemoryConfig.summarizationModel) {
-        logger.debug("[ContextCompactor] Stage 3 skipped: no summarization provider or model available");
-        return { summarized: false, messages };
-    }
-    const summaryText = await generateSummary(messagesToSummarize, effectiveMemoryConfig, "[ContextCompactor]", previousSummary);
-    if (!summaryText) {
-        return { summarized: false, messages };
-    }
-    const summaryMessage = {
-        id: `summary-${randomUUID()}`,
-        role: "user",
-        content: `[Previous conversation summary]:\n\n${summaryText}`,
-        timestamp: new Date().toISOString(),
-        metadata: {
-            isSummary: true,
-            summarizesFrom: messagesToSummarize[0]?.id,
-            summarizesTo: messagesToSummarize[messagesToSummarize.length - 1]?.id,
-        },
-    };
-    return {
-        summarized: true,
-        messages: [summaryMessage, ...recentMessages],
-        summaryText,
-    };
-}
-//# sourceMappingURL=structuredSummarizer.js.map

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

@@ -1,8 +0,0 @@
-/**
- * Stage 1: Tool Output Pruning
- *
- * Walk messages backwards, protect recent tool output tokens,
- * replace older tool results with "[Tool result cleared]".
- */
-import type { ChatMessage, PruneConfig, PruneResult } from "../../types/index.js";
-export declare function pruneToolOutputs(messages: ChatMessage[], config?: PruneConfig): PruneResult;

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

@@ -1,53 +0,0 @@
-/**
- * Stage 1: Tool Output Pruning
- *
- * Walk messages backwards, protect recent tool output tokens,
- * replace older tool results with "[Tool result cleared]".
- */
-import { estimateTokens } from "../../utils/tokenEstimation.js";
-const CLEARED_PLACEHOLDER = "[Tool result cleared]";
-const DEFAULT_PROTECT_TOKENS = 40_000;
-const DEFAULT_MINIMUM_SAVINGS = 20_000;
-export function pruneToolOutputs(messages, config) {
-    const protectTokens = config?.protectTokens ?? DEFAULT_PROTECT_TOKENS;
-    const minimumSavings = config?.minimumSavings ?? DEFAULT_MINIMUM_SAVINGS;
-    const protectedTools = new Set(config?.protectedTools ?? ["skill"]);
-    const provider = config?.provider;
-    const result = [...messages];
-    let recentToolTokens = 0;
-    let totalSaved = 0;
-    // Walk backwards to protect recent tool outputs
-    for (let i = result.length - 1; i >= 0; i--) {
-        const msg = result[i];
-        if (msg.role !== "tool_result") {
-            continue;
-        }
-        // Skip protected tools
-        if (msg.tool && protectedTools.has(msg.tool)) {
-            continue;
-        }
-        const contentTokens = estimateTokens(msg.content, provider);
-        if (recentToolTokens < protectTokens) {
-            // This tool output is within the protection window
-            recentToolTokens += contentTokens;
-            continue;
-        }
-        // This tool output is old enough to prune
-        if (msg.content !== CLEARED_PLACEHOLDER) {
-            totalSaved +=
-                contentTokens - estimateTokens(CLEARED_PLACEHOLDER, provider);
-            result[i] = {
-                ...msg,
-                content: CLEARED_PLACEHOLDER,
-                metadata: { ...msg.metadata, truncated: true },
-            };
-        }
-    }
-    const pruned = totalSaved >= minimumSavings;
-    return {
-        pruned,
-        messages: pruned ? result : messages,
-        tokensSaved: pruned ? totalSaved : 0,
-    };
-}
-//# sourceMappingURL=toolOutputPruner.js.map

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

@@ -1,61 +0,0 @@
-/**
- * Per-step context budget guard for the AI-SDK agent loop.
- *
- * Pre-call budgeting (`checkContextBudget` + compaction) runs ONCE before
- * dispatch and only sees the input/session conversation. The AI-SDK tool loop
- * then appends assistant turns and tool results on every step — growth the
- * pre-call pipeline never sees, which is how long agentic runs overflow the
- * model's real context window mid-loop (provider 400s after dozens of tool
- * calls). The googleVertex native loops already guard this via
- * `createContextGuard`; this module brings the AI-SDK path (every provider
- * that delegates to `generateText`) to parity — and goes one step further:
- * instead of stopping the loop, it deterministically reclaims budget so the
- * loop can CONTINUE.
- *
- * Wired in `GenerationHandler.callGenerateText` through
- * `experimental_prepareStep`, whose result may replace the step's `messages`.
- * The guard operates on `ModelMessage[]` natively (no lossy ChatMessage
- * round-trip) and never makes LLM calls:
- *
- *   Stage 1 — truncate OLD tool outputs to head/tail previews
- *             (`generateToolOutputPreview`), oldest first, outside the
- *             protected recent tail.
- *   Stage 2 — drop the oldest complete tool exchanges (assistant tool-call
- *             message + its following tool-result messages, as a unit, so
- *             call/result pairing stays intact), replacing them with a single
- *             elision note.
- *
- * The system prompt and tool definitions ride OUTSIDE the step messages (the
- * handler hoists system into generateText's `system` option), so their cost is
- * passed in as `fixedOverheadTokens`. The first user message (the task) and
- * the most recent messages are never touched.
- */
-import type { ModelMessage, StepBudgetGuardConfig } from "../types/index.js";
-/** Estimate the token cost of a step's message array. */
-export declare function estimateStepMessagesTokens(messages: readonly ModelMessage[], provider?: string): number;
-/**
- * Estimate the fixed per-request overhead: hoisted system prompt + tool
- * definitions. Mirrors `checkContextBudget`'s categories for the pieces that
- * do not live in the step messages.
- */
-export declare function estimateFixedOverheadTokens(system: unknown, tools: Record<string, unknown> | undefined, provider?: string): number;
-/**
- * Create a per-step budget guard. Returns a function that, given the step's
- * messages (and optionally the REAL input-token count the provider reported
- * for the previous step), returns a compacted replacement array when the
- * projected request exceeds the threshold — or `undefined` when no change is
- * needed.
- *
- * Two dynamic behaviours:
- *  - the available-input budget is re-resolved on EVERY invocation, so
- *    runtime window discovery (`/model/info`, overflow self-healing) that
- *    lands mid-loop takes effect immediately instead of the guard staying
- *    frozen on the value captured at loop start;
- *  - usage feedback calibrates the estimator: the ratio between the real
- *    prompt tokens of the previous step and this guard's own estimate for
- *    what that step sent scales later estimates (only UP — underestimates
- *    overflow, overestimates merely compact earlier), eliminating the
- *    char-based estimator's drift on dense code/diff content without
- *    shipping a tokenizer.
- */
-export declare function createStepBudgetGuard(config: StepBudgetGuardConfig): (messages: readonly ModelMessage[], observedInputTokensLastStep?: number) => ModelMessage[] | undefined;