@juspay/neurolink 12.0.3 → 12.0.5

package/dist/neurolink.js

@@ -5548,7 +5548,15 @@ Current user's request: ${currentInput}`;
                 : "empty",
             hasCustomSystemPrompt: !!options.systemPrompt,
         });
-        const conversationMessages = (await getConversationMessages(this.conversationMemory, options));
+        // Caller-supplied conversationMessages win — mirroring
+        // directProviderGeneration. getConversationMessages() returns [] whenever
+        // no memory manager / session context is configured, which silently
+        // dropped an inline history on the MCP-first path (the default path for
+        // any bare `new NeuroLink()` with tools enabled) while the direct path
+        // honored it.
+        const conversationMessages = (options.conversationMessages?.length
+            ? options.conversationMessages
+            : await getConversationMessages(this.conversationMemory, options));
         this.logMCPConversationSummary(requestId, conversationMessages);
         logger.debug("[Observability] Available tools for LLM", {
             requestId,
@@ -6062,32 +6070,118 @@ Current user's request: ${currentInput}`;
                 // oversized case. When the budget check shows the request is
                 // over budget but there's nothing to compact (no memory + no
                 // inline messages — e.g. a huge prompt or huge tool definitions
-                // alone), throw before dispatch instead of wasting a roundtrip.
+                // alone), recover by WINDOWING the prompt when the prompt is what
+                // blew the budget: keep its head and tail around an elision marker
+                // and dispatch. Agentic callers (Yama's session loop) carry their
+                // whole tool transcript in the prompt; the previous
+                // unconditional throw dead-ended every such turn — observed live
+                // as an unbounded retry loop (93K→299K tokens, no verdict, ever).
+                // The throw remains for the truly unrecoverable case: system
+                // prompt + tool definitions alone exceed the budget.
+                let promptWindowRecovered = false;
                 if (!budgetCheck.withinBudget && !dpgHasCompactableMessages) {
-                    try {
-                        this.emitter.emit("compaction.insufficient", {
-                            stagesAttempted: ["pre-dispatch hard cap"],
-                            finalTokens: budgetCheck.estimatedInputTokens,
-                            budget: budgetCheck.availableInputTokens,
-                            provider: providerName,
-                            model: options.model,
-                            phase: "pre-dispatch-no-recovery",
-                            timestamp: Date.now(),
-                        });
+                    const fixedOverhead = (budgetCheck.breakdown?.systemPrompt ?? 0) +
+                        (budgetCheck.breakdown?.toolDefinitions ?? 0) +
+                        (budgetCheck.breakdown?.fileAttachments ?? 0);
+                    // 3% margin against estimator drift; 1024-token floor — below
+                    // that, a windowed prompt carries too little to answer from.
+                    const promptBudget = Math.floor((budgetCheck.availableInputTokens - fixedOverhead) * 0.97);
+                    const promptText = typeof options.prompt === "string" ? options.prompt : undefined;
+                    if (promptText &&
+                        promptBudget >= 1024 &&
+                        (budgetCheck.breakdown?.currentPrompt ?? 0) > promptBudget) {
+                        const marker = "\n\n[... middle of this prompt elided by NeuroLink to fit the model's context window ...]\n\n";
+                        // Proportional char budget from the observed chars-per-token of
+                        // THIS text, re-checked and shrunk until the estimator agrees.
+                        let charBudget = Math.floor(promptText.length *
+                            (promptBudget /
+                                Math.max(budgetCheck.breakdown?.currentPrompt ?? 1, 1)));
+                        let windowed = promptText;
+                        for (let attempt = 0; attempt < 4; attempt++) {
+                            const headChars = Math.floor(charBudget * 0.6);
+                            const tailChars = Math.max(charBudget - headChars - marker.length, 0);
+                            windowed =
+                                promptText.slice(0, headChars) +
+                                    marker +
+                                    (tailChars > 0 ? promptText.slice(-tailChars) : "");
+                            const recheck = checkContextBudget({
+                                provider: providerName,
+                                model: options.model,
+                                maxTokens: options.maxTokens,
+                                systemPrompt: options.systemPrompt,
+                                conversationMessages: [],
+                                currentPrompt: windowed,
+                                toolDefinitions: options.tools
+                                    ? Object.values(options.tools)
+                                    : undefined,
+                            });
+                            if (recheck.withinBudget) {
+                                break;
+                            }
+                            charBudget = Math.floor(charBudget * 0.8);
+                            if (attempt === 3) {
+                                windowed = promptText; // give up — fall through to the throw
+                            }
+                        }
+                        if (windowed !== promptText) {
+                            logger.warn("[NeuroLink] Prompt exceeded the model's context budget with nothing to compact — " +
+                                "windowed the prompt (head+tail kept, middle elided) to fit.", {
+                                provider: providerName,
+                                model: options.model,
+                                estimatedTokens: budgetCheck.estimatedInputTokens,
+                                budget: budgetCheck.availableInputTokens,
+                                originalPromptChars: promptText.length,
+                                windowedPromptChars: windowed.length,
+                            });
+                            try {
+                                this.emitter.emit("compaction.applied", {
+                                    stagesAttempted: ["pre-dispatch prompt window"],
+                                    finalTokens: budgetCheck.availableInputTokens,
+                                    budget: budgetCheck.availableInputTokens,
+                                    provider: providerName,
+                                    model: options.model,
+                                    phase: "pre-dispatch-prompt-window",
+                                    timestamp: Date.now(),
+                                });
+                            }
+                            catch {
+                                /* listener errors are non-fatal */
+                            }
+                            options.prompt = windowed;
+                            const inputHolder = options
+                                .input;
+                            if (inputHolder && typeof inputHolder.text === "string") {
+                                inputHolder.text = windowed;
+                            }
+                            promptWindowRecovered = true;
+                        }
                     }
-                    catch {
-                        /* listener errors are non-fatal */
+                    if (!promptWindowRecovered) {
+                        try {
+                            this.emitter.emit("compaction.insufficient", {
+                                stagesAttempted: ["pre-dispatch hard cap"],
+                                finalTokens: budgetCheck.estimatedInputTokens,
+                                budget: budgetCheck.availableInputTokens,
+                                provider: providerName,
+                                model: options.model,
+                                phase: "pre-dispatch-no-recovery",
+                                timestamp: Date.now(),
+                            });
+                        }
+                        catch {
+                            /* listener errors are non-fatal */
+                        }
+                        throw new ContextBudgetExceededError(`Context exceeds model budget and no compaction is possible ` +
+                            `(no conversationMemory, no inline conversationMessages — only ` +
+                            `prompt + tools). Estimated: ${budgetCheck.estimatedInputTokens} ` +
+                            `tokens, budget: ${budgetCheck.availableInputTokens} tokens. ` +
+                            `Reduce prompt or tool-definition size, or trim the request.`, {
+                            estimatedTokens: budgetCheck.estimatedInputTokens,
+                            availableTokens: budgetCheck.availableInputTokens,
+                            stagesUsed: [],
+                            breakdown: budgetCheck.breakdown,
+                        });
                     }
-                    throw new ContextBudgetExceededError(`Context exceeds model budget and no compaction is possible ` +
-                        `(no conversationMemory, no inline conversationMessages — only ` +
-                        `prompt + tools). Estimated: ${budgetCheck.estimatedInputTokens} ` +
-                        `tokens, budget: ${budgetCheck.availableInputTokens} tokens. ` +
-                        `Reduce prompt or tool-definition size, or trim the request.`, {
-                        estimatedTokens: budgetCheck.estimatedInputTokens,
-                        availableTokens: budgetCheck.availableInputTokens,
-                        stagesUsed: [],
-                        breakdown: budgetCheck.breakdown,
-                    });
                 }
                 if (budgetCheck.shouldCompact &&
                     (this.conversationMemory || dpgHasInlineMessages) &&

package/dist/rag/ragIntegration.js

@@ -235,9 +235,47 @@ async function _prepareRAGToolInner(ragConfig, fallbackProvider) {
     const EMBEDDING_DIMENSION = 128;
     const vectorStore = new InMemoryVectorStore();
     const indexName = "rag-index";
+    // When the caller configured an embedding provider/model, embed BOTH the
+    // index chunks and (below) the queries through that provider — previously
+    // those config fields had no runtime effect and retrieval always used the
+    // deterministic hash embedding, which is a lexical fingerprint rather than
+    // a semantic space. Index and query must share one embedding space, so the
+    // provider path replaces the hash path wholesale; any provider failure
+    // falls back to the hash for both sides.
+    const wantProviderEmbeddings = Boolean(embeddingProvider || embeddingModel);
+    const embedProviderName = embeddingProvider || fallbackProvider || "vertex";
+    const embedModelName = embeddingModel || "gemini-2.5-flash";
+    let embedFn = (text) => Promise.resolve(generateSimpleEmbedding(text, EMBEDDING_DIMENSION));
+    if (wantProviderEmbeddings) {
+        try {
+            const { AIProviderFactory } = await import("../core/factory.js");
+            const embedderProvider = (await AIProviderFactory.createProvider(embedProviderName, embedModelName));
+            if (typeof embedderProvider.embed === "function") {
+                const providerEmbed = embedderProvider.embed.bind(embedderProvider);
+                embedFn = (text) => providerEmbed(text, embedModelName);
+            }
+            else {
+                logger.warn(`[RAG] Embedding provider '${embedProviderName}' has no embed(); falling back to hash embeddings`);
+            }
+        }
+        catch (error) {
+            logger.warn("[RAG] Failed to create embedding provider; falling back to hash embeddings", { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    let chunkVectors;
+    try {
+        chunkVectors = await Promise.all(allChunks.map((chunk) => embedFn(chunk.text)));
+    }
+    catch (error) {
+        // One failed chunk must not leave a mixed-space index — flip the whole
+        // index AND all queries back to the hash space together.
+        logger.warn("[RAG] Provider embedding failed mid-index; falling back to hash embeddings for index and queries", { error: error instanceof Error ? error.message : String(error) });
+        embedFn = (text) => Promise.resolve(generateSimpleEmbedding(text, EMBEDDING_DIMENSION));
+        chunkVectors = allChunks.map((chunk) => generateSimpleEmbedding(chunk.text, EMBEDDING_DIMENSION));
+    }
     const items = allChunks.map((chunk, i) => ({
         id: `rag-chunk-${i}`,
-        vector: generateSimpleEmbedding(chunk.text, EMBEDDING_DIMENSION),
+        vector: chunkVectors[i],
         metadata: {
             text: chunk.text,
             ...chunk.metadata,
@@ -274,9 +312,9 @@ async function _prepareRAGToolInner(ragConfig, fallbackProvider) {
                     "rag.top_k": topK ?? 5,
                 },
             }, async (span) => {
-                // For the in-memory store with simple embeddings,
-                // generate a query embedding using the same method
-                const queryEmbedding = generateSimpleEmbedding(query, EMBEDDING_DIMENSION);
+                // Query through the same embedding space the index was built in —
+                // provider embeddings when configured (and healthy), else the hash.
+                const queryEmbedding = await embedFn(query).catch(() => generateSimpleEmbedding(query, EMBEDDING_DIMENSION));
                 // Fetch more candidates than needed so diversity can select across files
                 const fetchK = fileContents.length > 1 ? topK * 3 : topK;
                 const rawResults = await vectorStore.query({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.0.3",
+  "version": "12.0.5",
   "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": {