@juspay/neurolink 10.10.4 → 10.10.6

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

@@ -412,6 +412,79 @@ export type RepairResult = {
     orphanedCallsFixed: number;
     orphanedResultsFixed: number;
 };
+/**
+ * Provider-neutral view of ONE message in an agent loop's history.
+ *
+ * Every native provider loop keeps its history in a different shape (AI-SDK
+ * `ModelMessage`, OpenAI-compatible `{role,tool_calls}`, Gemini `contents`
+ * parts, Anthropic content blocks). The reclaim POLICY is identical across all
+ * of them, so adapters map their own shape onto this view, ask the core what to
+ * do, and apply the answer themselves.
+ */
+export type LoopGuardEntry = {
+    /** `toolCall` and `toolResult` form the batches the policy keeps intact. */
+    kind: "other" | "toolCall" | "toolResult";
+    /** Estimated tokens this entry currently costs. */
+    tokens: number;
+    /**
+     * Tokens this entry would cost with its payload replaced by a head/tail
+     * preview. Omitted when the entry cannot usefully shrink — which is exactly
+     * the case that forces the policy to drop batches instead.
+     */
+    previewTokens?: number;
+};
+/** What the caller should do to reclaim budget. Indices refer to the input array. */
+export type LoopGuardPlan = {
+    /** False when the loop is under threshold and nothing should change. */
+    fire: boolean;
+    /** Entries whose payload should be replaced by a preview. */
+    truncate: number[];
+    /** Entries to remove entirely — always whole batches, never a partial pair. */
+    drop: number[];
+    /** Estimated total after applying the plan, including fixed overhead. */
+    projectedTokens: number;
+};
+/**
+ * Structural view of one Anthropic content block, loose enough to accept the
+ * official SDK's `ContentBlockParam` union and NeuroLink's own
+ * `VertexAnthropicMessage` blocks without a cast at either call site.
+ */
+export type AnthropicGuardBlock = {
+    type: string;
+    /** Payload of a `tool_result` block. Other block kinds carry other fields. */
+    content?: unknown;
+    /** Text of a `text` block. */
+    text?: string;
+};
+/**
+ * Structural view of one Anthropic-shaped message, as used by both the direct
+ * Anthropic loop and the native Vertex+Claude path. Tool calls ride as
+ * `tool_use` blocks on an assistant message; their answers ride as
+ * `tool_result` blocks on the following user message.
+ */
+export type AnthropicGuardMessage = {
+    /**
+     * `system` is included because the installed `@anthropic-ai/sdk` widens
+     * `MessageParam["role"]` to accept it; narrowing here would make the SDK's
+     * own array unassignable at the call site.
+     */
+    role: "user" | "assistant" | "system";
+    content: string | AnthropicGuardBlock[];
+};
+/** Tuning for {@link planLoopGuardReclaim}. */
+export type LoopGuardPolicy = {
+    availableInputTokens: number;
+    /** System prompt + tool definitions — rides outside the message array. */
+    fixedOverheadTokens: number;
+    /** Fraction of the window at which the guard fires. */
+    thresholdRatio?: number;
+    /** Fraction of the window the guard reclaims down to once it fires. */
+    lowWaterRatio?: number;
+    /** Newest entries the guard must never modify. */
+    protectedTailCount?: number;
+    /** Observed/estimated token ratio, used to tighten both marks. */
+    calibration?: number;
+};
 /**
  * One contiguous tool batch: the run of `tool_call` messages emitted by a
  * single agent step, plus the run of `tool_result` messages that follows it.

package/dist/lib/types/conversationMemoryInterface.d.ts

@@ -32,6 +32,28 @@ export type IConversationMemoryManager = {
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
     /** Replace the entire messages array for a session */
     setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages on the session.
+     *
+     * Declared on the interface so every backend can implement it. Previously
+     * only the Redis manager had it, and the caller reached it by casting — so
+     * on in-memory storage tool activity never became messages at all, and the
+     * compaction, pruning and pair-repair paths saw a different history shape
+     * depending on `STORAGE_TYPE`.
+     */
+    storeToolExecution?(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        output?: unknown;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>, currentTime?: Date): Promise<void>;
     /** Close/shutdown the memory manager and release resources (e.g., Redis connections) */
     close?(): Promise<void>;
 };

package/dist/neurolink.d.ts

@@ -1787,8 +1787,14 @@ export declare class NeuroLink {
         [key: string]: unknown;
     }>, currentTime?: Date): Promise<void>;
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable(): boolean;
     /**

package/dist/neurolink.js

@@ -11129,11 +11129,16 @@ Current user's request: ${currentInput}`;
             });
             return;
         }
-        // Type guard to ensure it's Redis conversation memory manager
-        const redisMemory = this
-            .conversationMemory;
+        // Any backend that implements storeToolExecution — no longer a Redis cast.
+        // The in-memory manager implements it too, so tool activity becomes
+        // tool_call/tool_result messages regardless of STORAGE_TYPE.
+        const memory = this.conversationMemory;
+        if (!memory?.storeToolExecution) {
+            logger.debug("Tool execution storage not supported by this memory backend");
+            return;
+        }
         try {
-            await redisMemory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
+            await memory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
         }
         catch (error) {
             logger.warn("Failed to store tool executions", {
@@ -11145,15 +11150,17 @@ Current user's request: ${currentInput}`;
         }
     }
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable() {
-        const isRedisStorage = process.env.STORAGE_TYPE === "redis";
-        const hasRedisConversationMemory = this.conversationMemory &&
-            this.conversationMemory.constructor.name ===
-                "RedisConversationMemoryManager";
-        return !!(isRedisStorage && hasRedisConversationMemory);
+        return typeof this.conversationMemory?.storeToolExecution === "function";
     }
     /**
      * Get the raw messages array for a session.

package/dist/providers/anthropic/client.js

@@ -14,6 +14,9 @@ import { createProxyFetch } from "../../proxy/proxyFetch.js";
 import { getCapturedLimitSnapshot, getCapturedResponseHeaders, logClaudeLimitSnapshot, runInLimitCaptureScope, setLimitSpanAttributes, withLimitCapture, wrapFetchWithLimitCapture, } from "./rateLimitCapture.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { logger } from "../../utils/logger.js";
+import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
+import { getAvailableInputTokens } from "../../constants/contextWindows.js";
+import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../../utils/anthropicCacheBreakpoints.js";
 import { calculateCost } from "../../utils/pricing.js";
@@ -1509,8 +1512,30 @@ export class AnthropicProvider extends BaseProvider {
         // and stay fully incremental.
         let bufferedText = "";
         let finalResultText;
+        /** System prompt + tool definitions: they ride outside `messages`. */
+        const estimateAnthropicFixedOverhead = (system, tools) => {
+            const text = (value) => {
+                if (typeof value === "string") {
+                    return value;
+                }
+                try {
+                    return JSON.stringify(value) ?? "";
+                }
+                catch {
+                    return "";
+                }
+            };
+            return (estimateTokens(text(system), "anthropic") +
+                estimateTokens(text(tools), "anthropic"));
+        };
         const runLoop = async () => {
             const conversation = payload.messages.slice();
+            // The provider's REAL prompt-token count for the previous step,
+            // calibrating the guard's char-based estimate for free, paired with the
+            // guard's own estimate for that same request — a ratio between counts of
+            // two different payloads would be meaningless.
+            let lastObservedPromptTokens;
+            let lastSentEstimate;
             for (let step = 0; step < maxSteps; step++) {
                 // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
                 // new tools into toolsRecord between steps; Claude only calls tools
@@ -1524,6 +1549,71 @@ export class AnthropicProvider extends BaseProvider {
                         logger.info(`[Anthropic] ${Object.keys(hydrated).length} tool(s) hydrated mid-turn via discovery: ${Object.keys(hydrated).join(", ")}`);
                     }
                 }
+                // In-turn context guard. This loop appends an assistant tool_use
+                // message plus a user tool_result message every step — growth the
+                // pre-dispatch budget check never sees. Without it a long agentic run
+                // overflows the window mid-loop and loses every completed step.
+                // Returns undefined while the request still fits, leaving the history
+                // byte-identical so the rolling cache prefix below stays valid.
+                const reclaim = planAnthropicLoopReclaim({
+                    conversation,
+                    availableInputTokens: getAvailableInputTokens("anthropic", modelId, options.maxTokens ?? undefined),
+                    fixedOverheadTokens: estimateAnthropicFixedOverhead(payload.system, anthropicTools),
+                    provider: "anthropic",
+                    observedPromptTokens: lastObservedPromptTokens,
+                    // Both halves of the calibration ratio must describe the same
+                    // request: the tokens the provider reported, and this guard's own
+                    // estimate for what was sent to earn them.
+                    previousSentEstimate: lastSentEstimate,
+                    onSentEstimate: (tokens) => {
+                        lastSentEstimate = tokens;
+                    },
+                });
+                if (reclaim) {
+                    // Applied HERE, in the loop's own concrete types: the guard decides,
+                    // the caller mutates. Dropping an assistant tool_use message together
+                    // with its user tool_result message is what keeps blocks paired.
+                    const dropSet = new Set(reclaim.drop);
+                    const truncateSet = new Set(reclaim.truncate);
+                    const rebuilt = [];
+                    for (let i = 0; i < conversation.length; i++) {
+                        if (dropSet.has(i)) {
+                            continue;
+                        }
+                        const message = conversation[i];
+                        if (truncateSet.has(i) && Array.isArray(message.content)) {
+                            rebuilt.push({
+                                ...message,
+                                content: message.content.map((block) => block.type === "tool_result"
+                                    ? {
+                                        ...block,
+                                        content: previewAnthropicToolResultText(typeof block.content === "string"
+                                            ? block.content
+                                            : (JSON.stringify(block.content) ?? "")),
+                                    }
+                                    : block),
+                            });
+                            continue;
+                        }
+                        rebuilt.push(message);
+                    }
+                    if (dropSet.size > 0) {
+                        // Anthropic requires user/assistant alternation around tool blocks;
+                        // the note is a user turn placed immediately before the first
+                        // surviving assistant tool_use turn, which preserves it.
+                        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 }],
+                        });
+                    }
+                    conversation.length = 0;
+                    conversation.push(...rebuilt);
+                }
                 // Prompt-cache parity with the native Vertex+Claude path — rolling
                 // history breakpoints, re-applied per step so the stable prefix
                 // stays byte-identical while the breakpoint follows the growing
@@ -1587,6 +1677,14 @@ export class AnthropicProvider extends BaseProvider {
                         totalCacheRead += event.message.usage.cache_read_input_tokens ?? 0;
                         totalCacheWrite +=
                             event.message.usage.cache_creation_input_tokens ?? 0;
+                        // Calibration signal for the in-turn guard: the FULL prompt size,
+                        // which on this path means uncached input plus both cache tiers.
+                        // Using input_tokens alone would read a cache-hit step as tiny and
+                        // let the guard drift far under the real cost.
+                        lastObservedPromptTokens =
+                            (event.message.usage.input_tokens ?? 0) +
+                                (event.message.usage.cache_read_input_tokens ?? 0) +
+                                (event.message.usage.cache_creation_input_tokens ?? 0);
                     }
                     else if (event.type === "content_block_start") {
                         blockTypes.set(event.index, event.content_block.type);

package/dist/providers/openaiChatCompletionsBase.js

@@ -17,7 +17,8 @@
  * Nothing here imports from "ai" or "@ai-sdk/*". The base class is a
  * direct HTTP client + multi-step tool-execution loop driven by SSE.
  */
-import { getRuntimeContextWindow, getRuntimeOutputCeiling, registerRuntimeContextWindow, } from "../constants/contextWindows.js";
+import { getAvailableInputTokens, getRuntimeContextWindow, getRuntimeOutputCeiling, registerRuntimeContextWindow, } from "../constants/contextWindows.js";
+import { guardOpenAICompatConversation } from "../context/openaiCompatLoopGuard.js";
 import { isContextOverflowError, parseProviderOverflowDetails, } from "../context/errorDetection.js";
 import { ContextBudgetExceededError } from "../context/errors.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -770,6 +771,12 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             // May grow mid-turn: hydrated tools with wire-unsafe names need
             // reverse-mapping even when the initial name set required none.
             let effectiveToolNameFromWire = toolNameFromWire;
+            // The provider's REAL prompt-token count for the previous step, used to
+            // calibrate the guard's char-based estimate for free, paired with the
+            // guard's own estimate for that same request — a ratio between counts of
+            // two different payloads would be meaningless.
+            let lastObservedPromptTokens;
+            let lastSentEstimate;
             for (let step = 0; step < maxSteps; step++) {
                 // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
                 // new tools into toolsRecord between steps. Dispatch already re-reads
@@ -795,6 +802,35 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         logger.info(`${this.providerName}: ${Object.keys(hydrated).length} tool(s) hydrated mid-turn via discovery: ${Object.keys(hydrated).join(", ")}`);
                     }
                 }
+                // In-turn context guard. This loop appends an assistant tool-call
+                // message plus one tool message per result on every step — growth the
+                // pre-dispatch budget check never sees. Without this, a long agentic
+                // run walks into a provider "context length exceeded" and loses every
+                // completed step. Shares its reclaim policy with the other provider
+                // loops via loopGuardCore; returns undefined (leaving `conversation`
+                // byte-identical) whenever the request still fits, so a loop that fits
+                // never pays a prompt-cache invalidation.
+                const guarded = guardOpenAICompatConversation({
+                    conversation,
+                    availableInputTokens: getAvailableInputTokens(this.providerName, modelId, options.maxTokens ?? undefined),
+                    // Tool definitions ride outside the message array. Passing an empty
+                    // message list yields the tools-only overhead, and reuses the same
+                    // estimator the wire path already trusts.
+                    fixedOverheadTokens: estimateWireTokens([], openAITools, this.providerName),
+                    provider: this.providerName,
+                    observedPromptTokens: lastObservedPromptTokens,
+                    // Both halves of the calibration ratio must describe the same
+                    // request: the tokens the provider reported, and this guard's own
+                    // estimate for what was sent to earn them.
+                    previousSentEstimate: lastSentEstimate,
+                    onSentEstimate: (tokens) => {
+                        lastSentEstimate = tokens;
+                    },
+                });
+                if (guarded) {
+                    conversation.length = 0;
+                    conversation.push(...guarded);
+                }
                 const stepResult = await this.streamOneStep({
                     modelId,
                     url,
@@ -806,6 +842,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     openAIToolChoice,
                     pushChunk,
                 });
+                lastObservedPromptTokens = stepResult.usage?.prompt_tokens;
                 stepFinish = stepResult.finishReason;
                 if (stepResult.usage) {
                     stepUsage = mergeUsage(stepUsage, stepResult.usage);

package/dist/types/context.d.ts

@@ -412,6 +412,79 @@ export type RepairResult = {
     orphanedCallsFixed: number;
     orphanedResultsFixed: number;
 };
+/**
+ * Provider-neutral view of ONE message in an agent loop's history.
+ *
+ * Every native provider loop keeps its history in a different shape (AI-SDK
+ * `ModelMessage`, OpenAI-compatible `{role,tool_calls}`, Gemini `contents`
+ * parts, Anthropic content blocks). The reclaim POLICY is identical across all
+ * of them, so adapters map their own shape onto this view, ask the core what to
+ * do, and apply the answer themselves.
+ */
+export type LoopGuardEntry = {
+    /** `toolCall` and `toolResult` form the batches the policy keeps intact. */
+    kind: "other" | "toolCall" | "toolResult";
+    /** Estimated tokens this entry currently costs. */
+    tokens: number;
+    /**
+     * Tokens this entry would cost with its payload replaced by a head/tail
+     * preview. Omitted when the entry cannot usefully shrink — which is exactly
+     * the case that forces the policy to drop batches instead.
+     */
+    previewTokens?: number;
+};
+/** What the caller should do to reclaim budget. Indices refer to the input array. */
+export type LoopGuardPlan = {
+    /** False when the loop is under threshold and nothing should change. */
+    fire: boolean;
+    /** Entries whose payload should be replaced by a preview. */
+    truncate: number[];
+    /** Entries to remove entirely — always whole batches, never a partial pair. */
+    drop: number[];
+    /** Estimated total after applying the plan, including fixed overhead. */
+    projectedTokens: number;
+};
+/**
+ * Structural view of one Anthropic content block, loose enough to accept the
+ * official SDK's `ContentBlockParam` union and NeuroLink's own
+ * `VertexAnthropicMessage` blocks without a cast at either call site.
+ */
+export type AnthropicGuardBlock = {
+    type: string;
+    /** Payload of a `tool_result` block. Other block kinds carry other fields. */
+    content?: unknown;
+    /** Text of a `text` block. */
+    text?: string;
+};
+/**
+ * Structural view of one Anthropic-shaped message, as used by both the direct
+ * Anthropic loop and the native Vertex+Claude path. Tool calls ride as
+ * `tool_use` blocks on an assistant message; their answers ride as
+ * `tool_result` blocks on the following user message.
+ */
+export type AnthropicGuardMessage = {
+    /**
+     * `system` is included because the installed `@anthropic-ai/sdk` widens
+     * `MessageParam["role"]` to accept it; narrowing here would make the SDK's
+     * own array unassignable at the call site.
+     */
+    role: "user" | "assistant" | "system";
+    content: string | AnthropicGuardBlock[];
+};
+/** Tuning for {@link planLoopGuardReclaim}. */
+export type LoopGuardPolicy = {
+    availableInputTokens: number;
+    /** System prompt + tool definitions — rides outside the message array. */
+    fixedOverheadTokens: number;
+    /** Fraction of the window at which the guard fires. */
+    thresholdRatio?: number;
+    /** Fraction of the window the guard reclaims down to once it fires. */
+    lowWaterRatio?: number;
+    /** Newest entries the guard must never modify. */
+    protectedTailCount?: number;
+    /** Observed/estimated token ratio, used to tighten both marks. */
+    calibration?: number;
+};
 /**
  * One contiguous tool batch: the run of `tool_call` messages emitted by a
  * single agent step, plus the run of `tool_result` messages that follows it.

package/dist/types/conversationMemoryInterface.d.ts

@@ -32,6 +32,28 @@ export type IConversationMemoryManager = {
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
     /** Replace the entire messages array for a session */
     setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages on the session.
+     *
+     * Declared on the interface so every backend can implement it. Previously
+     * only the Redis manager had it, and the caller reached it by casting — so
+     * on in-memory storage tool activity never became messages at all, and the
+     * compaction, pruning and pair-repair paths saw a different history shape
+     * depending on `STORAGE_TYPE`.
+     */
+    storeToolExecution?(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        output?: unknown;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>, currentTime?: Date): Promise<void>;
     /** Close/shutdown the memory manager and release resources (e.g., Redis connections) */
     close?(): Promise<void>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.10.4",
+  "version": "10.10.6",
   "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": {
@@ -85,6 +85,10 @@
     "test:tool-pairing": "npx tsx test/continuous-test-suite-tool-pairing.ts",
     "test:token-accounting": "npx tsx test/continuous-test-suite-token-accounting.ts",
     "test:step-guard": "npx tsx test/continuous-test-suite-step-guard.ts",
+    "test:loop-guard-core": "npx tsx test/continuous-test-suite-loop-guard-core.ts",
+    "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: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",