@juspay/neurolink 10.10.6 → 10.10.7

package/dist/providers/googleVertex/client.js

@@ -16,6 +16,8 @@ import { applyVertexAnthropicCacheBreakpoints } from "../../utils/anthropicCache
 import { FileDetector } from "../../utils/fileDetector.js";
 import { mergeMediaFileAliases, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
+import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
+import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
 import { detectImageMimeType } from "../../utils/imageDetection.js";
 import { resolveClaudeMaxTokens } from "../../utils/tokenLimits.js";
@@ -25,7 +27,7 @@ import { createNativeThinkingConfig } from "../../utils/thinkingConfig.js";
 import { TimeoutError, raceWithAbort, withTimeout, } from "../../utils/async/index.js";
 import { parseTimeout } from "../../utils/timeout.js";
 import { appendStepText, buildAbortedTurnMessage, buildContextCapMessage, buildToolLoopCapMessage, buildTurnStalledMessage, buildTurnTimeoutMessage, buildWrapupNudgeText, createContextGuard, createTextChannel, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
-import { getContextWindowSize } from "../../constants/contextWindows.js";
+import { getAvailableInputTokens, getContextWindowSize, } from "../../constants/contextWindows.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.js";
 import { ATTR, LANGFUSE_ATTR, spanJsonAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../../telemetry/index.js";
 import { SpanKind, SpanStatusCode, context as otelContext, trace as otelTrace, } from "@opentelemetry/api";
@@ -587,6 +589,148 @@ const isAnthropicModel = (modelName) => {
  *       Solution: Simplify schema or reduce number of tools if this occurs.
  * @see https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models
  */
+/** Byte budget above which an old tool response is previewed, not kept whole. */
+const TOOL_RESPONSE_PREVIEW_BYTES = 2048;
+/**
+ * Reclaim context from a Gemini-shaped loop history IN PLACE.
+ *
+ * Returns true when something was actually reclaimed, which tells the caller
+ * it is safe to continue the loop instead of stopping. Mutates `contents` so
+ * the caller's array identity (captured by the request builder) stays valid.
+ */
+function reclaimVertexLoopContext(contents, modelName, observedPromptTokens) {
+    const plan = planGeminiLoopReclaim({
+        contents,
+        // The usable INPUT budget, not the whole window: the window has to hold the
+        // model's output too, and the AI Studio twin already reclaims against this
+        // same definition.
+        availableInputTokens: getAvailableInputTokens("vertex", modelName),
+        provider: "vertex",
+        observedPromptTokens,
+    });
+    if (!plan) {
+        return false;
+    }
+    const dropSet = new Set(plan.drop);
+    const truncateSet = new Set(plan.truncate);
+    const rebuilt = [];
+    for (let i = 0; i < contents.length; i++) {
+        if (dropSet.has(i)) {
+            continue;
+        }
+        const content = contents[i];
+        if (truncateSet.has(i) && Array.isArray(content.parts)) {
+            rebuilt.push({
+                ...content,
+                parts: content.parts.map((part) => {
+                    if (!("functionResponse" in part)) {
+                        return part;
+                    }
+                    const fn = part.functionResponse;
+                    const text = JSON.stringify(fn.response) ?? "";
+                    if (text.length <= TOOL_RESPONSE_PREVIEW_BYTES) {
+                        return part;
+                    }
+                    // Rebuilt rather than cast: `functionResponse` requires `name`, and
+                    // Critical Rule 14 forbids casting through `unknown` to paper over it.
+                    return {
+                        functionResponse: {
+                            name: fn.name,
+                            response: { result: previewGeminiToolResponseText(text) },
+                        },
+                    };
+                }),
+            });
+            continue;
+        }
+        rebuilt.push(content);
+    }
+    if (dropSet.size > 0) {
+        // Gemini requires the history to start with a user turn; the note is
+        // inserted before the first surviving tool turn, never at the end where a
+        // "history was removed" cue would follow the content it refers to.
+        let noteIndex = rebuilt.findIndex((c) => Array.isArray(c.parts) &&
+            c.parts.some((part) => !!part.functionCall ||
+                !!part.functionResponse));
+        if (noteIndex < 0) {
+            noteIndex = Math.min(1, rebuilt.length);
+        }
+        rebuilt.splice(noteIndex, 0, {
+            role: "user",
+            parts: [{ text: GEMINI_ELISION_NOTE }],
+        });
+    }
+    contents.length = 0;
+    contents.push(...rebuilt);
+    return true;
+}
+/**
+ * Reclaim context from a Vertex+Claude loop history IN PLACE.
+ *
+ * Same parity upgrade as the Gemini path, but this loop carries Anthropic
+ * content blocks, so it reuses the Anthropic adapter. Returns true when
+ * something was reclaimed and the loop may continue.
+ */
+function reclaimVertexAnthropicContext(messages, modelName, observedPromptTokens) {
+    const plan = planAnthropicLoopReclaim({
+        conversation: messages,
+        // Usable input budget, matching the Gemini twin above.
+        availableInputTokens: getAvailableInputTokens("vertex", modelName),
+        fixedOverheadTokens: 0,
+        provider: "vertex",
+        observedPromptTokens,
+        // This loop plans only when its context guard trips, so the count it hands
+        // over is the guard's projection for the request about to be sent, not a
+        // previous request's total. Without saying so the planner has no
+        // denominator, calibration stays pinned at 1, and the reclaim is inert:
+        // the guard fires on real tokens at the same ratio the planner tests its
+        // smaller char estimate against, so the plan never fires and the turn stops
+        // instead of continuing.
+        observedDescribesCurrentPayload: true,
+    });
+    if (!plan) {
+        return false;
+    }
+    const dropSet = new Set(plan.drop);
+    const truncateSet = new Set(plan.truncate);
+    const rebuilt = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (dropSet.has(i)) {
+            continue;
+        }
+        const message = messages[i];
+        if (truncateSet.has(i) && Array.isArray(message.content)) {
+            rebuilt.push({
+                ...message,
+                content: message.content.map((block) => {
+                    if (block.type !== "tool_result") {
+                        return block;
+                    }
+                    const text = typeof block.content === "string"
+                        ? block.content
+                        : (JSON.stringify(block.content) ?? "");
+                    return { ...block, content: previewAnthropicToolResultText(text) };
+                }),
+            });
+            continue;
+        }
+        rebuilt.push(message);
+    }
+    if (dropSet.size > 0) {
+        let noteIndex = rebuilt.findIndex((m) => Array.isArray(m.content) &&
+            m.content.some((b) => b.type === "tool_use" || b.type === "tool_result"));
+        if (noteIndex < 0) {
+            noteIndex = Math.min(1, rebuilt.length);
+        }
+        rebuilt.splice(noteIndex, 0, {
+            role: "user",
+            content: [{ type: "text", text: ANTHROPIC_ELISION_NOTE }],
+        });
+    }
+    messages.length = 0;
+    messages.push(...rebuilt);
+    return true;
+}
 export class GoogleVertexProvider extends BaseProvider {
     projectId;
     location;
@@ -1574,11 +1718,22 @@ export class GoogleVertexProvider extends BaseProvider {
                 // conversation crosses the window threshold — synthesize from what
                 // we have instead of stepping into a provider rejection.
                 if (contextGuard.shouldStop()) {
-                    hitContextLimit = true;
-                    logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
-                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                    break;
+                    // Parity upgrade: try to RECLAIM budget and keep going before
+                    // falling back to the historic stop-only behaviour. Ending the turn
+                    // early is safe but throws away work the model was mid-way through;
+                    // dropping the oldest complete tool exchanges usually buys enough
+                    // room to finish. Only when reclaiming changes nothing do we stop.
+                    const reclaimed = reclaimVertexLoopContext(currentContents, modelName, contextGuard.projectedNextPromptTokens);
+                    if (reclaimed) {
+                        contextGuard.resetAfterReclaim();
+                    }
+                    else {
+                        hitContextLimit = true;
+                        logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
+                            `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                            `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                        break;
+                    }
                 }
                 step++;
                 turnClock.noteProgress();
@@ -2550,11 +2705,22 @@ export class GoogleVertexProvider extends BaseProvider {
                 // conversation crosses the window threshold — synthesize from what
                 // we have instead of stepping into a provider rejection.
                 if (contextGuard.shouldStop()) {
-                    hitContextLimit = true;
-                    logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
-                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                    break;
+                    // Parity upgrade: try to RECLAIM budget and keep going before
+                    // falling back to the historic stop-only behaviour. Ending the turn
+                    // early is safe but throws away work the model was mid-way through;
+                    // dropping the oldest complete tool exchanges usually buys enough
+                    // room to finish. Only when reclaiming changes nothing do we stop.
+                    const reclaimed = reclaimVertexLoopContext(currentContents, modelName, contextGuard.projectedNextPromptTokens);
+                    if (reclaimed) {
+                        contextGuard.resetAfterReclaim();
+                    }
+                    else {
+                        hitContextLimit = true;
+                        logger.warn(`[GoogleVertex] Gemini turn stopped by the context guard: ` +
+                            `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                            `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                        break;
+                    }
                 }
                 step++;
                 turnClock.noteProgress();
@@ -3671,11 +3837,19 @@ export class GoogleVertexProvider extends BaseProvider {
                     // Context guard: stop the tool loop before the accumulated
                     // conversation crosses the window threshold (see generate twin).
                     if (contextGuard.shouldStop()) {
-                        hitContextLimit = true;
-                        logger.warn(`[GoogleVertex] Anthropic stream turn stopped by the context guard: ` +
-                            `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                            `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                        break;
+                        // Parity upgrade: reclaim and continue where possible; the
+                        // historic stop-only behaviour remains the fallback.
+                        const reclaimed = reclaimVertexAnthropicContext(currentMessages, modelName, contextGuard.projectedNextPromptTokens);
+                        if (reclaimed) {
+                            contextGuard.resetAfterReclaim();
+                        }
+                        else {
+                            hitContextLimit = true;
+                            logger.warn(`[GoogleVertex] Anthropic stream turn stopped by the context guard: ` +
+                                `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                                `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                            break;
+                        }
                     }
                     step++;
                     turnClock.noteProgress();
@@ -4929,11 +5103,17 @@ export class GoogleVertexProvider extends BaseProvider {
             // this step's appended tool results/output) would cross the window
             // threshold — stop the tool loop and synthesize from what we have.
             if (contextGuard.shouldStop()) {
-                hitContextLimit = true;
-                logger.warn(`[GoogleVertex] Anthropic generate turn stopped by the context guard: ` +
-                    `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
-                    `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
-                break;
+                const reclaimed = reclaimVertexAnthropicContext(currentMessages, modelName, contextGuard.projectedNextPromptTokens);
+                if (reclaimed) {
+                    contextGuard.resetAfterReclaim();
+                }
+                else {
+                    hitContextLimit = true;
+                    logger.warn(`[GoogleVertex] Anthropic generate turn stopped by the context guard: ` +
+                        `projected prompt ~${contextGuard.projectedNextPromptTokens} tokens ` +
+                        `>= threshold ${contextGuard.thresholdTokens} (step ${step}) — synthesizing a final answer.`);
+                    break;
+                }
             }
             step++;
             turnClock.noteProgress();

package/dist/types/context.d.ts

@@ -471,6 +471,15 @@ export type AnthropicGuardMessage = {
     role: "user" | "assistant" | "system";
     content: string | AnthropicGuardBlock[];
 };
+/**
+ * Structural view of one Gemini history entry, loose enough to accept both the
+ * native Vertex loop's `{ role, parts }` array and `@google/genai` contents
+ * without a cast at either call site.
+ */
+export type GeminiGuardContent = {
+    role: string;
+    parts: unknown[];
+};
 /** Tuning for {@link planLoopGuardReclaim}. */
 export type LoopGuardPolicy = {
     availableInputTokens: number;

package/dist/utils/redis.d.ts

@@ -2,7 +2,7 @@
  * Redis Utilities for NeuroLink
  * Helper functions for Redis storage operations
  */
-import type { RedisClient, RedisConversationObject, RedisStorageConfig } from "../types/index.js";
+import type { ChatMessage, RedisClient, RedisConversationObject, RedisStorageConfig } from "../types/index.js";
 /**
  * Get a pooled Redis connection. Multiple callers with the same host:port:db
  * share a single connection, reducing connection count.
@@ -36,6 +36,28 @@ export declare function getUserSessionsKey(config: Required<RedisStorageConfig>,
  * Serializes conversation object for Redis storage
  */
 export declare function serializeConversation(conversation: RedisConversationObject): string;
+/**
+ * True for a complete `ChatMessage` — `id` included, because callers keying
+ * summary pointers and condensation groups off it are entitled to find one.
+ */
+export declare function isStoredChatMessage(value: unknown): value is ChatMessage;
+/**
+ * Coerce a stored entry into a complete `ChatMessage`, or `undefined` when its
+ * shape is unusable.
+ *
+ * Shared by BOTH read paths on purpose. Inline blobs have always been
+ * validated; once messages moved into the companion LIST the split read
+ * bypassed that check, so `null`, a number or a bare string survived
+ * `JSON.parse` and reached callers that dereference `.role`, `.content` and
+ * `.metadata`. The two storage formats must offer the same read guarantee.
+ *
+ * `id` is a separate matter: it is required on `ChatMessage`, but no read path
+ * has ever enforced it, so history written before it existed carries none.
+ * Rejecting those records would empty otherwise-healthy sessions, so a missing
+ * id is backfilled rather than fatal — prefixed, so a synthesized id is never
+ * mistaken for one an existing pointer could reference.
+ */
+export declare function normalizeStoredMessage(value: unknown): ChatMessage | undefined;
 /**
  * Deserializes conversation object from Redis storage
  */
@@ -58,3 +80,40 @@ export declare function scanKeys(client: RedisClient, pattern: string, batchSize
  * Get normalized Redis configuration with defaults
  */
 export declare function getNormalizedConfig(config: RedisStorageConfig): Required<RedisStorageConfig>;
+/**
+ * Suffix of the companion LIST key holding a session's messages.
+ *
+ * Every `storeConversationTurn` used to re-serialize and SET the ENTIRE
+ * conversation, so per-turn write cost grew with history size. Measured
+ * against local Redis: 200 turns of 2KB messages stayed flat at 2ms, but 400
+ * turns of 20KB messages (~16MB blob) went 2ms -> 61ms, a 30x degradation on
+ * exactly the agentic tool-output profile. Splitting messages into an
+ * append-only LIST makes the per-turn write O(1) in conversation size.
+ */
+export declare const MESSAGES_KEY_SUFFIX = ":msgs";
+/**
+ * Marker on a stored blob meaning "messages live in the companion LIST".
+ * A blob WITHOUT it is a legacy record whose inline `messages` array is
+ * authoritative — it is read as-is and converted on its next write, which is
+ * what makes this migration backward compatible.
+ */
+export declare const MESSAGES_IN_LIST_MARKER = "__nlMessagesInList";
+/** Redis key holding a session's messages as an append-only LIST. */
+export declare function getSessionMessagesKey(config: Required<RedisStorageConfig>, sessionId: string, userId?: string): string;
+/**
+ * True for a companion messages LIST key.
+ *
+ * Scan-then-GET paths (`getStats`, session listing) match `${keyPrefix}*`, so
+ * they now also see these LIST keys — and `GET` on a LIST raises WRONGTYPE.
+ * They must filter with this, exactly as they already skip `:sessions` index
+ * keys.
+ */
+export declare function isSessionMessagesKey(key: string): boolean;
+/** Serialize the conversation WITHOUT its messages, flagged for split reads. */
+export declare function serializeConversationMetadata(conversation: RedisConversationObject): string;
+/** True when a deserialized blob's messages live in the companion LIST. */
+export declare function usesSplitMessageStorage(conversation: RedisConversationObject | null | undefined): boolean;
+/** Parse LRANGE entries, skipping any single entry that is not usable. */
+export declare function parseStoredMessages(entries: string[]): ChatMessage[];
+/** Encode messages for RPUSH. */
+export declare function encodeStoredMessages(messages: ChatMessage[]): string[];

package/dist/utils/redis.js

@@ -2,6 +2,7 @@
  * Redis Utilities for NeuroLink
  * Helper functions for Redis storage operations
  */
+import { randomUUID } from "crypto";
 import { createClient } from "redis";
 import { logger } from "./logger.js";
 const SESSION_ONLY_PREFIX = "session-only:";
@@ -198,6 +199,65 @@ export function serializeConversation(conversation) {
         throw error;
     }
 }
+/** The exact role set `ChatMessage` allows. */
+const STORED_MESSAGE_ROLES = new Set([
+    "user",
+    "assistant",
+    "system",
+    "tool_call",
+    "tool_result",
+]);
+function isStoredMessageRole(role) {
+    return typeof role === "string" && STORED_MESSAGE_ROLES.has(role);
+}
+/**
+ * True for a complete `ChatMessage` — `id` included, because callers keying
+ * summary pointers and condensation groups off it are entitled to find one.
+ */
+export function isStoredChatMessage(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.id === "string" &&
+        typeof candidate.content === "string" &&
+        isStoredMessageRole(candidate.role));
+}
+/**
+ * Coerce a stored entry into a complete `ChatMessage`, or `undefined` when its
+ * shape is unusable.
+ *
+ * Shared by BOTH read paths on purpose. Inline blobs have always been
+ * validated; once messages moved into the companion LIST the split read
+ * bypassed that check, so `null`, a number or a bare string survived
+ * `JSON.parse` and reached callers that dereference `.role`, `.content` and
+ * `.metadata`. The two storage formats must offer the same read guarantee.
+ *
+ * `id` is a separate matter: it is required on `ChatMessage`, but no read path
+ * has ever enforced it, so history written before it existed carries none.
+ * Rejecting those records would empty otherwise-healthy sessions, so a missing
+ * id is backfilled rather than fatal — prefixed, so a synthesized id is never
+ * mistaken for one an existing pointer could reference.
+ */
+export function normalizeStoredMessage(value) {
+    if (isStoredChatMessage(value)) {
+        return value;
+    }
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const candidate = value;
+    if (typeof candidate.content !== "string" ||
+        !isStoredMessageRole(candidate.role)) {
+        return undefined;
+    }
+    return {
+        ...candidate,
+        id: `legacy-${randomUUID()}`,
+        role: candidate.role,
+        content: candidate.content,
+    };
+}
 /**
  * Deserializes conversation object from Redis storage
  */
@@ -235,18 +295,8 @@ export function deserializeConversation(data) {
             return null;
         }
         // Validate each message in the messages array
-        const isValidHistory = conversation.messages.every((m) => typeof m === "object" &&
-            m !== null &&
-            "role" in m &&
-            "content" in m &&
-            typeof m.role === "string" &&
-            typeof m.content === "string" &&
-            (m.role === "user" ||
-                m.role === "assistant" ||
-                m.role === "system" ||
-                m.role === "tool_call" ||
-                m.role === "tool_result"));
-        if (!isValidHistory) {
+        const normalizedMessages = conversation.messages.map(normalizeStoredMessage);
+        if (normalizedMessages.some((message) => message === undefined)) {
             logger.warn("[redisUtils] Invalid messages structure", {
                 messageCount: conversation.messages.length,
                 firstMessage: conversation.messages.length > 0
@@ -255,6 +305,7 @@ export function deserializeConversation(data) {
             });
             return null;
         }
+        conversation.messages = normalizedMessages.filter((message) => message !== undefined);
         logger.debug("[redisUtils] Conversation deserialized successfully", {
             sessionId: conversation.sessionId,
             userId: conversation.userId,
@@ -396,3 +447,83 @@ export function getNormalizedConfig(config) {
         },
     };
 }
+// ---------------------------------------------------------------------------
+// Split message storage
+// ---------------------------------------------------------------------------
+/**
+ * Suffix of the companion LIST key holding a session's messages.
+ *
+ * Every `storeConversationTurn` used to re-serialize and SET the ENTIRE
+ * conversation, so per-turn write cost grew with history size. Measured
+ * against local Redis: 200 turns of 2KB messages stayed flat at 2ms, but 400
+ * turns of 20KB messages (~16MB blob) went 2ms -> 61ms, a 30x degradation on
+ * exactly the agentic tool-output profile. Splitting messages into an
+ * append-only LIST makes the per-turn write O(1) in conversation size.
+ */
+export const MESSAGES_KEY_SUFFIX = ":msgs";
+/**
+ * Marker on a stored blob meaning "messages live in the companion LIST".
+ * A blob WITHOUT it is a legacy record whose inline `messages` array is
+ * authoritative — it is read as-is and converted on its next write, which is
+ * what makes this migration backward compatible.
+ */
+export const MESSAGES_IN_LIST_MARKER = "__nlMessagesInList";
+/** Redis key holding a session's messages as an append-only LIST. */
+export function getSessionMessagesKey(config, sessionId, userId) {
+    return `${getSessionKey(config, sessionId, userId)}${MESSAGES_KEY_SUFFIX}`;
+}
+/**
+ * True for a companion messages LIST key.
+ *
+ * Scan-then-GET paths (`getStats`, session listing) match `${keyPrefix}*`, so
+ * they now also see these LIST keys — and `GET` on a LIST raises WRONGTYPE.
+ * They must filter with this, exactly as they already skip `:sessions` index
+ * keys.
+ */
+export function isSessionMessagesKey(key) {
+    return key.endsWith(MESSAGES_KEY_SUFFIX);
+}
+/** Serialize the conversation WITHOUT its messages, flagged for split reads. */
+export function serializeConversationMetadata(conversation) {
+    return JSON.stringify({
+        ...conversation,
+        messages: [],
+        [MESSAGES_IN_LIST_MARKER]: true,
+    });
+}
+/** True when a deserialized blob's messages live in the companion LIST. */
+export function usesSplitMessageStorage(conversation) {
+    if (!conversation) {
+        return false;
+    }
+    const record = conversation;
+    return record[MESSAGES_IN_LIST_MARKER] === true;
+}
+/** Parse LRANGE entries, skipping any single entry that is not usable. */
+export function parseStoredMessages(entries) {
+    const messages = [];
+    for (const entry of entries) {
+        try {
+            // `JSON.parse` succeeds for `null`, numbers and bare strings, so the
+            // catch below cannot filter them — the shape has to be checked.
+            const parsed = JSON.parse(entry);
+            const message = normalizeStoredMessage(parsed);
+            if (!message) {
+                logger.warn("[redisUtils] Skipping stored message with invalid shape");
+                continue;
+            }
+            messages.push(message);
+        }
+        catch (error) {
+            // One corrupt entry must not destroy a whole session's history.
+            logger.warn("[redisUtils] Skipping unparseable stored message", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return messages;
+}
+/** Encode messages for RPUSH. */
+export function encodeStoredMessages(messages) {
+    return messages.map((message) => JSON.stringify(message));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.10.6",
+  "version": "10.10.7",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -89,6 +89,8 @@
     "test:openai-compat-guard": "npx tsx test/continuous-test-suite-openai-compat-guard.ts",
     "test:anthropic-guard": "npx tsx test/continuous-test-suite-anthropic-guard.ts",
     "test:tool-storage-parity": "npx tsx test/continuous-test-suite-tool-storage-parity.ts",
+    "test:redis-append-only": "npx tsx test/continuous-test-suite-redis-append-only.ts",
+    "test:gemini-guard": "npx tsx test/continuous-test-suite-gemini-guard.ts",
     "test:middleware": "npx tsx test/continuous-test-suite-middleware.ts",
     "test:observability": "npx tsx test/continuous-test-suite-observability.ts",
     "test:ppt": "npx tsx test/continuous-test-suite-ppt.ts",