@juspay/neurolink 10.10.6 → 10.10.8

package/dist/cli/factories/commandFactory.js

@@ -166,15 +166,19 @@ export class CLICommandFactory {
             type: "string",
             description: "Add video file for analysis (can be used multiple times) (MP4, WebM, MOV, AVI, MKV)",
         },
+        // No yargs `default:` on these two. They used to declare 8 / 85 while the
+        // processor actually picks a duration-based frame count (up to 100) and
+        // encodes at quality 80 — harmless only because the values were never read
+        // (#478). Now that they reach the encoder, a default here would silently
+        // re-cap every existing CLI video at 8 frames. Unset means "let the
+        // processor choose", which is what callers have always effectively had.
         "video-frames": {
             type: "number",
-            default: 8,
-            description: "Number of frames to extract (default: 8)",
+            description: "Number of frames to extract (default: chosen from video duration, max 100)",
         },
         "video-quality": {
             type: "number",
-            default: 85,
-            description: "Frame quality 0-100 (default: 85)",
+            description: "Frame quality 1-100 (default: 80)",
         },
         "video-format": {
             type: "string",

package/dist/constants/contextWindows.js

@@ -376,7 +376,16 @@ export const MODEL_CONTEXT_WINDOWS = {
  * `lm-studio` -> `lmstudio`, `nvidia-nim` -> `nvidianim`, `llama.cpp` -> `llamacpp`.
  */
 const PROVIDER_ALIAS_MAP = {
-    googleaistudio: "google-ai-studio",
+    // Both spellings resolve to `google-ai`, the ONLY key this table holds for
+    // AI Studio. `google-ai-studio` was never a key, so every realistic spelling
+    // ("googleAiStudio" from the native client, "google-ai-studio", "googleai")
+    // missed the table and fell back to DEFAULT_CONTEXT_WINDOW — reporting
+    // 128K for a 1,048,576-token Gemini. That understated the loop-guard budget
+    // by ~8x, so AI Studio agent loops reclaimed tool history that still fitted
+    // comfortably. `google-ai` itself only resolved via the raw-provider
+    // fallback below, which the normalized lookup now covers directly.
+    googleaistudio: "google-ai",
+    googleai: "google-ai",
     lmstudio: "lm-studio",
     llamacpp: "llamacpp",
     nvidianim: "nvidia-nim",

package/dist/context/anthropicLoopGuard.d.ts

@@ -43,4 +43,5 @@ export declare function planAnthropicLoopReclaim(args: {
     observedPromptTokens?: number;
     previousSentEstimate?: number;
     onSentEstimate?: (tokens: number) => void;
+    observedDescribesCurrentPayload?: boolean;
 }): LoopGuardPlan | undefined;

package/dist/context/anthropicLoopGuard.js

@@ -125,25 +125,43 @@ export function isAnthropicToolResultMessage(message) {
  * `cache_control` prefix this path depends on.
  */
 export function planAnthropicLoopReclaim(args) {
-    const { conversation, availableInputTokens, fixedOverheadTokens, provider, observedPromptTokens, previousSentEstimate, onSentEstimate, } = args;
+    const { conversation, availableInputTokens, fixedOverheadTokens, provider, observedPromptTokens, previousSentEstimate, onSentEstimate, observedDescribesCurrentPayload = false, } = 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_use message plus its tool_result, 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.
+    // Calibration divides a real prompt-token count by THIS guard's estimate for
+    // the payload that count describes. Both halves must describe the SAME
+    // payload, and there are two legitimate pairings:
+    //
+    //  - A caller that plans on EVERY step passes the provider's count for the
+    //    previous request together with `previousSentEstimate`, the estimate
+    //    recorded for that same request. Dividing that count by the estimate for
+    //    the CURRENT conversation would be a category error — the loop has since
+    //    appended an assistant tool_use message plus its tool_result, so the
+    //    denominator is always the larger of the two, the ratio reads below 1 and
+    //    the `Math.max(1, …)` floor pins calibration at 1. The correction then
+    //    silently never applies, which is exactly when a dense-code run overflows.
+    //
+    //  - A caller that plans only when a real-token guard trips has no estimate
+    //    for an earlier request, but its trigger (`projectedNextPromptTokens`) is
+    //    already a projection of the payload ABOUT TO BE SENT. It sets
+    //    `observedDescribesCurrentPayload`, and the denominator is this module's
+    //    estimate of the current history — the same payload again.
+    //
+    // Without the flag such a caller gets calibration 1, which makes its reclaim
+    // inert: the guard trips on real tokens at the same ratio this planner tests
+    // its (smaller) char estimate against, so the plan never fires and the loop
+    // falls back to stopping the turn.
+    const sentEstimate = observedDescribesCurrentPayload
+        ? rawEstimate
+        : previousSentEstimate;
     let calibration = 1;
     if (observedPromptTokens &&
         observedPromptTokens > 0 &&
-        previousSentEstimate &&
-        previousSentEstimate > 0) {
+        sentEstimate &&
+        sentEstimate > 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));
+        calibration = Math.min(3, Math.max(1, observedPromptTokens / sentEstimate));
     }
     const plan = planLoopGuardReclaim(entries, {
         availableInputTokens,

package/dist/context/contextCompactor.js

@@ -200,6 +200,25 @@ export class ContextCompactor {
                     stagesUsed,
                     durationMs: Date.now() - spanStartTime,
                 });
+                // A compaction that was ASKED to reclaim and reclaimed nothing is the
+                // signature of a mis-aimed target: the caller decided the request was
+                // over budget, but every stage gate compared against a number that
+                // said otherwise, so the pipeline no-opped and the request went out
+                // oversized anyway. That is exactly how the history-budget defect hid
+                // in production — silently, because "Complete" looked healthy. Warn
+                // loudly and stamp the span so it is greppable and alertable.
+                const reclaimedNothing = stagesUsed.length === 0;
+                if (reclaimedNothing) {
+                    logger.warn("[Compaction] No-op — invoked but reclaimed nothing", {
+                        requestId,
+                        tokensBefore,
+                        targetTokens,
+                        messageCount: currentMessages.length,
+                    });
+                }
+                span = SpanSerializer.updateAttributes(span, {
+                    "context.noop": reclaimedNothing,
+                });
                 const result = {
                     compacted: stagesUsed.length > 0,
                     stagesUsed,

package/dist/context/geminiLoopGuard.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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/context/geminiLoopGuard.js

@@ -0,0 +1,140 @@
+/**
+ * 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;
+}

package/dist/core/redisConversationMemoryManager.d.ts

@@ -93,6 +93,33 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * Check if summarization is needed based on token count
      */
     private checkAndSummarize;
+    /**
+     * True only for keys holding a conversation BLOB — the sole key type these
+     * scan-then-GET paths may read.
+     *
+     * `${keyPrefix}*` also matches the companion message LISTs and, when a
+     * custom key prefix does not end in `conversation:`, the user-index SETs
+     * (whose derived prefix then collapses onto `keyPrefix`). `GET` against
+     * either raises WRONGTYPE, and counting them would inflate session totals.
+     */
+    private isConversationBlobKey;
+    /**
+     * Hydrate a deserialized blob's messages from the companion LIST when the
+     * session uses split storage. Legacy blobs (messages inline) pass through
+     * untouched — that is what makes the migration backward compatible.
+     */
+    private hydrateMessages;
+    /** Message count without materializing them — LLEN for split sessions. */
+    private countMessages;
+    /** Load a session, messages included, regardless of storage format. */
+    private loadConversation;
+    /**
+     * Persist a conversation, splitting messages into the companion LIST.
+     * `appendFrom` appends only messages from that index onward (the per-turn
+     * fast path); omit it to rewrite the LIST wholesale, which is also how a
+     * legacy blob gets converted.
+     */
+    private persistConversation;
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)