@juspay/neurolink 10.6.1 → 10.6.2

package/dist/neurolink.js

@@ -327,13 +327,23 @@ export function isNeuroLink(value) {
         value !== null &&
         value[NEUROLINK_BRAND] === true);
 }
+/**
+ * Create a Node {@link EventEmitter} exposed through the typed-emitter
+ * surface. The runtime object is a plain EventEmitter — the typed view only
+ * narrows the event-name/payload relationship for callers, so the widening
+ * hop through `unknown` is contained here once.
+ */
+function createTypedEmitter() {
+    const emitter = new EventEmitter();
+    return emitter;
+}
 export class NeuroLink {
     /** @internal Brand for cross-module identification — see {@link isNeuroLink}. */
     [NEUROLINK_BRAND] = true;
     mcpInitialized = false;
     mcpSkipped = false;
     mcpInitPromise = null;
-    emitter = new EventEmitter();
+    emitter = createTypedEmitter();
     // TaskManager — lazy-initialized on first access via `this.tasks`
     _taskManager;
     _taskManagerConfig;
@@ -1306,8 +1316,7 @@ export class NeuroLink {
             description: retrieveContextDef.description ?? "Retrieve context or artifacts",
             // Pass the Zod schema so ToolsManager gives the LLM full parameter types.
             // registerTool() detects isZodSchema on inputSchema and preserves it.
-            inputSchema: retrieveContextDef
-                .inputSchema,
+            inputSchema: retrieveContextDef.inputSchema,
             execute: async (params) => {
                 // Lazy: conversationMemory is initialized on the first generate() call.
                 // When only an artifact store is present (no Redis), memoryManager is
@@ -1362,8 +1371,7 @@ export class NeuroLink {
                 description: toolDef.description ?? toolName,
                 // Zod schema — registerTool() detects isZodSchema and preserves it
                 // so ToolsManager gives the LLM full parameter types.
-                inputSchema: toolDef
-                    .inputSchema,
+                inputSchema: toolDef.inputSchema,
                 execute: async (params) => withTimeout(toolDef.execute(params, { toolCallId: "skill-tool", messages: [] }), TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS, ErrorFactory.toolTimeout(toolName, TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS)),
             });
         }
@@ -8915,7 +8923,7 @@ Current user's request: ${currentInput}`;
     // ========================================
     // ENHANCED: Tool Event Emission API
     // ========================================
-    // TODO: Add ToolExecutionEvent utility methods in future version
+    // TODO(#1179): Add ToolExecutionEvent utility methods in future version
     // Will provide structured event format for consistent tool event processing
     /**
      * Emit tool start event with execution tracking
@@ -9038,7 +9046,7 @@ Current user's request: ${currentInput}`;
     clearCurrentStreamExecutions() {
         this.currentStreamToolExecutions = [];
     }
-    // TODO: Add getToolExecutionEvents() method in future version
+    // TODO(#1179): Add getToolExecutionEvents() method in future version
     // Will return properly formatted ToolExecutionEvent objects for structured event processing
     // ========================================
     // Tool Registration API

package/dist/processors/document/ExcelProcessor.js

@@ -271,7 +271,11 @@ export class ExcelProcessor extends BaseFileProcessor {
      */
     async parseWorkbook(buffer) {
         const ExcelJS = await loadExcelJS();
-        const workbook = new ExcelJS.Workbook();
+        // The exceljs constructor comes from a normalised CJS/ESM interop
+        // namespace (see loadExcelJS); probe the instance as `unknown` and
+        // narrow to the structural subset this processor uses.
+        const workbookInstance = new ExcelJS.Workbook();
+        const workbook = workbookInstance;
         // ExcelJS load() types expect Buffer but Node 22+ Buffer<ArrayBufferLike>
         // is not directly assignable. Extract a clean ArrayBuffer for the exact
         // byte range via slice, then cast for type compatibility.

package/dist/providers/amazonBedrock.js

@@ -155,7 +155,8 @@ export class AmazonBedrockProvider extends BaseProvider {
         // Clear conversation history for new generation
         this.conversationHistory = [];
         // Check for multimodal input (images, PDFs, CSVs, files)
-        // Cast to any to access multimodal properties (runtime check is safe)
+        // Narrow to the StreamOptions input shape to access multimodal
+        // properties (runtime check is safe)
         const input = options.input;
         const hasMultimodalInput = !!(input?.images?.length ||
             input?.content?.length ||
@@ -917,10 +918,8 @@ export class AmazonBedrockProvider extends BaseProvider {
                 logger.debug("[TRACE] executeStream CATCH - error caught from streamingConversationLoop");
                 const errorObj = error;
                 // Check if error is related to streaming permissions
-                const isPermissionError = errorObj?.name ===
-                    "AccessDeniedException" ||
-                    errorObj?.name ===
-                        "UnauthorizedOperation" ||
+                const isPermissionError = errorObj?.name === "AccessDeniedException" ||
+                    errorObj?.name === "UnauthorizedOperation" ||
                     errorObj?.message?.includes("bedrock:InvokeModelWithResponseStream") ||
                     errorObj?.message?.includes("streaming") ||
                     errorObj?.message?.includes("ConverseStream");

package/dist/providers/amazonSagemaker.d.ts

@@ -54,6 +54,24 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
      * Get model capabilities and information
      */
     getModelCapabilities(): {
+        capabilities: {
+            streaming: boolean;
+            toolCalling: boolean;
+            structuredOutput: boolean;
+            batchInference: boolean;
+            supportedResponseFormats: string[];
+            supportedToolTypes: string[];
+            maxBatchSize: number;
+            adaptiveConcurrency: boolean;
+            errorRecovery: boolean;
+        };
+        modelId: string;
+        provider: string;
+        specificationVersion: "v2";
+        endpointName: string;
+        modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
+        region: string;
+    } | {
         capabilities: {
             streaming: boolean;
             toolCalling: boolean;

package/dist/providers/amazonSagemaker.js

@@ -10,6 +10,9 @@ import { SageMakerLanguageModel } from "./sagemaker/language-model.js";
  * Amazon SageMaker Provider extending BaseProvider
  */
 export class AmazonSageMakerProvider extends BaseProvider {
+    // Kept as the concrete class so SageMaker-specific members
+    // (testConnectivity, getModelCapabilities) stay typed; getAISDKModel()
+    // narrows to the AI SDK handle shape at its boundary.
     sagemakerModel;
     sagemakerConfig;
     modelConfig;
@@ -41,8 +44,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
             // SageMakerLanguageModel implements SageMakerAsLanguageModel which is
             // structurally compatible with LanguageModelV2 (specificationVersion "v2",
             // modelId, provider, supportedUrls, doGenerate, doStream).
-            const smModel = new SageMakerLanguageModel(this.modelName, this.sagemakerConfig, this.modelConfig);
-            this.sagemakerModel = smModel;
+            this.sagemakerModel = new SageMakerLanguageModel(this.modelName, this.sagemakerConfig, this.modelConfig);
             logger.debug("Amazon SageMaker Provider initialized", {
                 modelName: this.modelName,
                 endpointName: this.modelConfig.endpointName,
@@ -66,7 +68,11 @@ export class AmazonSageMakerProvider extends BaseProvider {
         return getSageMakerModel();
     }
     getAISDKModel() {
-        return this.sagemakerModel;
+        // Same sanctioned two-step as construction previously used: the class
+        // satisfies the structural SageMakerAsLanguageModel shape, which is
+        // single-assertable to the AI SDK LanguageModel handle.
+        const smModel = this.sagemakerModel;
+        return smModel;
     }
     async executeStream(_options, _analysisSchema) {
         return withSpan({

package/dist/providers/anthropic.js

@@ -1072,7 +1072,11 @@ export class AnthropicProvider extends BaseProvider {
         const modelId = this.modelName || getDefaultAnthropicModel();
         const getTimeoutForOptions = (opts) => this.getTimeout((opts ?? {}));
         const refreshAuth = () => this.refreshAuthIfNeeded();
-        return {
+        // Structural AI-SDK model shape (`SageMakerAsLanguageModel`, the
+        // sanctioned intermediate from src/lib/types/providers.ts): assigning the
+        // literal to it keeps the compiler's member checks, and the intermediate
+        // is single-assertable to the ai-package `LanguageModel` handle.
+        const delegatingModel = {
             specificationVersion: "v3",
             provider: providerName,
             modelId,
@@ -1259,6 +1263,7 @@ export class AnthropicProvider extends BaseProvider {
                 throw new Error(`${providerName}: doStream is not implemented on the delegating model — the streaming path uses executeStream directly.`);
             },
         };
+        return delegatingModel;
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {

package/dist/providers/googleAiStudio.js

@@ -1282,10 +1282,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         if (queue.length > 0) {
                             const item = queue.shift();
                             if (!item) {
-                                return {
-                                    value: undefined,
-                                    done: true,
-                                };
+                                // `done: true` selects the IteratorReturnResult arm, whose
+                                // value type accepts undefined.
+                                return { value: undefined, done: true };
                             }
                             if (item.type === "audio") {
                                 return {
@@ -1295,10 +1294,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             }
                             if (item.type === "end") {
                                 done = true;
-                                return {
-                                    value: undefined,
-                                    done: true,
-                                };
+                                return { value: undefined, done: true };
                             }
                             if (item.type === "error") {
                                 done = true;
@@ -1308,10 +1304,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             }
                         }
                         if (done) {
-                            return {
-                                value: undefined,
-                                done: true,
-                            };
+                            return { value: undefined, done: true };
                         }
                         return await new Promise((resolve) => {
                             resolveNext = resolve;

package/dist/providers/googleVertex.js

@@ -1443,6 +1443,9 @@ export class GoogleVertexProvider extends BaseProvider {
         const maxSteps = Number.isFinite(rawMaxSteps) && rawMaxSteps > 0
             ? Math.min(Math.floor(rawMaxSteps), 100) // Cap at 100 for safety
             : Math.min(DEFAULT_MAX_STEPS, 100);
+        // Widened per-turn copy: the agentic loop appends functionCall /
+        // functionResponse parts on top of the plain text/inlineData parts the
+        // initial contents carry.
         const currentContents = [...contents];
         let finalText = "";
         // Last SDK finish reason seen across steps (Bug 2: previously never read,
@@ -1671,7 +1674,8 @@ export class GoogleVertexProvider extends BaseProvider {
                                 functionCall: fc,
                             })),
                     });
-                    // Execute each function and collect responses
+                    // Execute each function and collect responses (plus an optional
+                    // trailing wrap-up nudge text part).
                     const functionResponses = [];
                     // Per-step bookkeeping for conversation-memory storage.
                     const stepStorageCalls = [];
@@ -2080,6 +2084,10 @@ export class GoogleVertexProvider extends BaseProvider {
             // (assistant text empty but tools ran) and downstream consumers see
             // the same shape AI-SDK-driven providers expose.
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
+            // transformToolExecutions' record shape (name/input/output/duration) is
+            // what downstream consumers read at runtime; it shares no required
+            // members with the declared ToolExecutionSummary element type, so the
+            // assertion carries both shapes instead of erasing the real one.
             toolExecutions: transformToolExecutions(externalToolExecutions),
             metadata: {
                 streamId: `native-vertex-${Date.now()}`,
@@ -2378,6 +2386,9 @@ export class GoogleVertexProvider extends BaseProvider {
         const maxSteps = Number.isFinite(rawMaxSteps) && rawMaxSteps > 0
             ? Math.min(Math.floor(rawMaxSteps), 100) // Cap at 100 for safety
             : Math.min(DEFAULT_MAX_STEPS, 100);
+        // Widened per-turn copy: the agentic loop appends functionCall /
+        // functionResponse parts on top of the plain text/inlineData parts the
+        // initial contents carry.
         const currentContents = [...contents];
         let finalText = "";
         // Cross-step text accumulation + last SDK finish reason, so the
@@ -2595,7 +2606,8 @@ export class GoogleVertexProvider extends BaseProvider {
                                 functionCall: fc,
                             })),
                     });
-                    // Execute each function and collect responses
+                    // Execute each function and collect responses (plus an optional
+                    // trailing wrap-up nudge text part).
                     const functionResponses = [];
                     const toolCallsBefore = allToolCalls.length;
                     const toolExecsBefore = toolExecutions.length;
@@ -3094,9 +3106,18 @@ export class GoogleVertexProvider extends BaseProvider {
         // `prepareOptions()` is a separate continuation and still surfaces auth
         // errors to callers. `void` flags the returned promise as deliberately
         // ignored (codebase convention for fire-and-forget).
-        void client._authClientPromise?.catch(() => {
-            // Intentionally ignored — see above.
-        });
+        //
+        // `_authClientPromise` is a private SDK internal, so it is reached via
+        // runtime narrowing (`in` + `instanceof`) rather than a type assertion.
+        const clientInternals = client;
+        if ("_authClientPromise" in clientInternals) {
+            const authClientPromise = clientInternals._authClientPromise;
+            if (authClientPromise instanceof Promise) {
+                void authClientPromise.catch(() => {
+                    // Intentionally ignored — see above.
+                });
+            }
+        }
         return client;
     }
     /**

package/dist/providers/openaiChatCompletionsBase.js

@@ -291,6 +291,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
      */
     async getAISDKModel() {
         const modelId = await this.resolveModelName();
+        // buildDelegatingModel returns `unknown`, so this is a single
+        // unknown-to-target assertion.
         return this.buildDelegatingModel(modelId);
     }
     async resolveModelName() {

package/dist/providers/sagemaker/errors.js

@@ -192,7 +192,8 @@ export function handleSageMakerError(error, endpoint) {
 /**
  * Extract request ID from AWS SDK error for debugging
  *
- * @param error - Error object that might contain request ID
+ * @param error - Error object that might contain request ID (AWS SDK errors
+ *   carry it as an untyped extra field, so the value is treated as opaque)
  * @returns Request ID if found, undefined otherwise
  */
 function extractRequestId(error) {

package/dist/proxy/proxyFetch.js

@@ -509,10 +509,14 @@ async function executeProxiedFetch(input, init, proxyEnv) {
                 fetchInput = input;
             }
             const undici = await import("undici");
-            const response = await undici.fetch(fetchInput, {
+            // undici's fetch types and lib.dom's diverge on iterator helper details,
+            // so the runtime-identical response is typed as either flavor (widening
+            // assertion so control flow keeps the union) and narrowed
+            // (overlap-checked) back to the DOM flavor at the return boundary.
+            const response = (await undici.fetch(fetchInput, {
                 ...fetchInit,
                 dispatcher,
-            });
+            }));
             if (logger.shouldLog("debug")) {
                 const { parsed: responseBody, size: responseSize, type: responseType, headers: responseHeaders, } = await readResponseBody(response);
                 logger.debug("[Observability] HTTP response from LLM provider", {

package/dist/rag/ChunkerFactory.js

@@ -177,7 +177,7 @@ export class ChunkerFactory extends BaseFactory {
         }, DEFAULT_CHUNKER_METADATA.latex);
         // Register semantic chunker (placeholder - uses recursive as fallback)
         this.registerChunker("semantic", async (config) => {
-            // TODO: Implement dedicated SemanticChunker with LLM support
+            // TODO(#1179): Implement dedicated SemanticChunker with LLM support
             // For now, fall back to RecursiveChunker with semantic defaults
             const { RecursiveChunker } = await import("./chunkers/RecursiveChunker.js");
             return new RecursiveChunker(config);

package/dist/rag/chunking/semanticChunker.js

@@ -138,8 +138,7 @@ export class SemanticChunker {
     async getEmbeddings(segments, provider, modelName) {
         const embeddingProvider = await ProviderFactory.createProvider(provider, modelName);
         // Check if provider has embed method
-        if (typeof embeddingProvider.embed !==
-            "function") {
+        if (typeof embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${provider} does not support embeddings`);
         }
         const embeddings = [];

package/dist/rag/document/MDocument.js

@@ -210,8 +210,7 @@ export class MDocument {
             model: modelName,
         });
         const embeddingProvider = await ProviderFactory.createProvider(provider, modelName);
-        if (typeof embeddingProvider.embed !==
-            "function") {
+        if (typeof embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${provider} does not support embeddings`);
         }
         this.state.embeddings = [];

package/dist/rag/document/loaders.js

@@ -273,14 +273,27 @@ export class PDFLoader {
         return ext === ".pdf";
     }
     async loadPdfParser() {
+        // pdf-parse is an optional dependency — resolve it dynamically and
+        // validate at runtime that it exposes a callable parser (either the
+        // module itself or its default export) instead of blindly asserting.
+        let pdfParseModule;
         try {
-            // pdf-parse is an optional dependency - use dynamic import with type assertion
-            const pdfParse = (await import("pdf-parse"));
-            return pdfParse.default || pdfParse;
+            pdfParseModule = await import("pdf-parse");
         }
         catch {
             throw new Error("pdf-parse module not available");
         }
+        const candidate = (typeof pdfParseModule === "object" &&
+            pdfParseModule !== null &&
+            "default" in pdfParseModule
+            ? pdfParseModule.default
+            : undefined) || pdfParseModule;
+        if (typeof candidate !== "function") {
+            // Outside the try/catch so this message isn't swallowed by the
+            // module-not-available rethrow.
+            throw new Error("pdf-parse module does not export a parse function");
+        }
+        return candidate;
     }
     parsePageRange(range, totalPages) {
         const pages = [];

package/dist/rag/pipeline/RAGPipeline.js

@@ -371,8 +371,7 @@ export class RAGPipeline {
         if (!this.embeddingProvider) {
             throw new Error("Embedding provider not initialized");
         }
-        if (typeof this.embeddingProvider
-            .embed !== "function") {
+        if (typeof this.embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${this.config.embeddingModel.provider} does not support embeddings`);
         }
         return await withTimeout(this.embeddingProvider.embed(text), DEFAULT_TIMEOUT_MS, "Embedding generation timed out");

package/dist/rag/retrieval/hybridSearch.js

@@ -177,8 +177,7 @@ export function createHybridSearch(options) {
         try {
             // Generate query embedding
             const embeddingProvider = await ProviderFactory.createProvider(embeddingModel?.provider, embeddingModel?.modelName);
-            if (typeof embeddingProvider
-                .embed !== "function") {
+            if (typeof embeddingProvider.embed !== "function") {
                 throw new Error(`Embedding provider does not support the embed() method. ` +
                     `Please use a provider that supports embeddings (e.g., OpenAI text-embedding-3-small, Vertex text-embedding-004).`);
             }

package/dist/rag/retrieval/vectorQueryTool.js

@@ -66,8 +66,7 @@ export function createVectorQueryTool(config, vectorStore) {
                     // Generate query embedding
                     const embeddingProvider = await ProviderFactory.createProvider(embeddingModel.provider, embeddingModel.modelName);
                     // Check if provider has embed method
-                    if (typeof embeddingProvider
-                        .embed !== "function") {
+                    if (typeof embeddingProvider.embed !== "function") {
                         throw new Error(`Provider ${embeddingModel.provider} does not support embeddings`);
                     }
                     const queryEmbedding = await embeddingProvider.embed(params.query);

package/dist/sdk/toolRegistration.js

@@ -249,8 +249,12 @@ export function validateTool(name, tool) {
             throw new Error(`Tool '${name}' parameters must be an object. ` +
                 `Received: ${typeof tool.parameters}`);
         }
-        // Check for common schema validation methods (Zod uses 'parse', others might use 'validate')
-        const params = tool.parameters;
+        // Check for common schema validation methods (Zod uses 'parse', others might use 'validate').
+        // Despite the declared Zod type, callers may pass custom schema objects at
+        // runtime — this function's whole purpose is to validate that; probe as
+        // `unknown` and narrow to a generic record for feature detection.
+        const paramsCandidate = tool.parameters;
+        const params = paramsCandidate;
         const hasValidationMethod = typeof params.parse === "function" ||
             typeof params.validate === "function" ||
             "_def" in params; // Zod schemas have _def property

package/dist/server/middleware/cache.d.ts

@@ -83,6 +83,10 @@ export declare class LRUCache<K, V> {
      * Check if a key exists in the cache
      */
     has(key: K): boolean;
+    /**
+     * Iterate over all keys currently in the cache
+     */
+    keys(): IterableIterator<K>;
     /**
      * Delete a key from the cache
      */

package/dist/server/middleware/cache.js

@@ -219,6 +219,12 @@ export class LRUCache {
     has(key) {
         return this.cache.has(key);
     }
+    /**
+     * Iterate over all keys currently in the cache
+     */
+    keys() {
+        return this.cache.keys();
+    }
     /**
      * Delete a key from the cache
      */
@@ -335,9 +341,7 @@ export class ResponseCacheStore {
         // For production, consider using a more efficient data structure
         let invalidated = 0;
         const keysToDelete = [];
-        // Get all keys (requires accessing internal cache)
-        const internalCache = this.cache.cache;
-        for (const key of internalCache.keys()) {
+        for (const key of this.cache.keys()) {
             const matches = pattern instanceof RegExp ? pattern.test(key) : key.includes(pattern);
             if (matches) {
                 keysToDelete.push(key);

package/dist/server/middleware/validation.js

@@ -75,7 +75,8 @@ export function createRequestValidationMiddleware(config) {
                 const formattedError = errorFormatter(errors.map((e) => new ServerValidationError([e], ctx.requestId)));
                 const error = new ServerValidationError(errors, ctx.requestId);
                 // Attach formatted response to error
-                error.response = formattedError;
+                error.response =
+                    formattedError;
                 throw error;
             }
             return next();