@juspay/neurolink 9.5.2 → 9.6.0

package/dist/providers/sagemaker/detection.d.ts

@@ -8,7 +8,7 @@ import type { SageMakerConfig, SageMakerModelConfig } from "../../types/provider
 /**
  * Streaming capability information for an endpoint
  */
-export interface StreamingCapability {
+export type StreamingCapability = {
     /** Whether streaming is supported */
     supported: boolean;
     /** Detected streaming protocol */
@@ -28,11 +28,11 @@ export interface StreamingCapability {
         version?: string;
         tags?: string[];
     };
-}
+};
 /**
  * Model type detection result
  */
-export interface ModelDetectionResult {
+export type ModelDetectionResult = {
     /** Primary model type */
     type: StreamingCapability["modelType"];
     /** Detection confidence (0-1) */
@@ -41,11 +41,11 @@ export interface ModelDetectionResult {
     evidence: string[];
     /** Suggested configuration */
     suggestedConfig?: Partial<SageMakerModelConfig>;
-}
+};
 /**
  * Endpoint health and metadata information
  */
-export interface EndpointHealth {
+export type EndpointHealth = {
     /** Health status */
     status: "healthy" | "unhealthy" | "unknown";
     /** Response time in milliseconds */
@@ -59,7 +59,7 @@ export interface EndpointHealth {
         framework?: string;
         architecture?: string;
     };
-}
+};
 /**
  * SageMaker Model Detection and Capability Discovery Service
  */

package/dist/providers/sagemaker/diagnostics.d.ts

@@ -6,18 +6,18 @@
 /**
  * Simple diagnostic result interface
  */
-export interface DiagnosticResult {
+export type DiagnosticResult = {
     name: string;
     category: "configuration" | "connectivity" | "streaming";
     status: "pass" | "fail" | "warning";
     message: string;
     details?: string;
     recommendation?: string;
-}
+};
 /**
  * Diagnostic report interface
  */
-export interface DiagnosticReport {
+export type DiagnosticReport = {
     overallStatus: "healthy" | "issues" | "critical";
     results: DiagnosticResult[];
     summary: {
@@ -26,7 +26,7 @@ export interface DiagnosticReport {
         failed: number;
         warnings: number;
     };
-}
+};
 /**
  * Run quick diagnostics for SageMaker configuration
  */

package/dist/providers/sagemaker/parsers.d.ts

@@ -10,12 +10,12 @@ import { type StructuredOutputParser } from "./structured-parser.js";
  * Shared bracket counting state and utilities
  * Used by both validateJSONCompleteness and StructuredOutputParser
  */
-export interface BracketCountingState {
+export type BracketCountingState = {
     braceCount: number;
     bracketCount: number;
     inString: boolean;
     escapeNext: boolean;
-}
+};
 /**
  * Process a single character for bracket counting logic
  * Shared utility to avoid code duplication between parsers
@@ -44,7 +44,7 @@ export declare function parseToolCallArguments(args: string): {
 /**
  * Base interface for streaming response parsers
  */
-export interface StreamingParser {
+export type StreamingParser = {
     /** Parse a chunk of streaming data */
     parse(chunk: Uint8Array): SageMakerStreamChunk[];
     /** Check if a chunk indicates completion */
@@ -55,7 +55,7 @@ export interface StreamingParser {
     getName(): string;
     /** Reset parser state for new stream */
     reset(): void;
-}
+};
 /**
  * Abstract base parser with common functionality
  */

package/dist/rag/chunkers/RecursiveChunker.js

@@ -127,8 +127,8 @@ export class RecursiveChunker extends BaseChunker {
         for (let i = 0; i < chunks.length; i++) {
             let chunk = chunks[i] ?? "";
             // Add overlap from previous chunk
-            if (i > 0 && chunks[i - 1]) {
-                const prevChunk = chunks[i - 1];
+            const prevChunk = i > 0 ? chunks[i - 1] : undefined;
+            if (prevChunk) {
                 const overlapText = prevChunk.slice(-Math.min(overlap, prevChunk.length));
                 chunk = overlapText + chunk;
             }

package/dist/rag/document/loaders.d.ts

@@ -24,77 +24,12 @@
  * ```
  */
 import { MDocument } from "./MDocument.js";
-import type { DocumentType } from "../types.js";
-/**
- * Document loader options
- */
-export interface LoaderOptions {
-    /** Custom metadata to add to document */
-    metadata?: Record<string, unknown>;
-    /** Encoding for text files */
-    encoding?: BufferEncoding;
-    /** Document type override */
-    type?: DocumentType;
-}
-/**
- * Web loader options
- */
-export interface WebLoaderOptions extends LoaderOptions {
-    /** Request timeout in milliseconds */
-    timeout?: number;
-    /** Custom headers for request */
-    headers?: Record<string, string>;
-    /** Extract only main content (remove navigation, ads, etc.) */
-    extractMainContent?: boolean;
-    /** Selector for main content (CSS selector) */
-    contentSelector?: string;
-    /** User agent string */
-    userAgent?: string;
-}
-/**
- * PDF loader options
- */
-export interface PDFLoaderOptions extends LoaderOptions {
-    /** Page range to extract (e.g., "1-5" or "1,3,5") */
-    pageRange?: string;
-    /** Extract images as base64 */
-    extractImages?: boolean;
-    /** OCR for scanned documents */
-    enableOCR?: boolean;
-    /** Preserve layout formatting */
-    preserveLayout?: boolean;
-}
-/**
- * CSV loader options
- */
-export interface CSVLoaderOptions extends LoaderOptions {
-    /** Delimiter character */
-    delimiter?: string;
-    /** Whether first row is header */
-    hasHeader?: boolean;
-    /** Column names (if no header) */
-    columns?: string[];
-    /** Output format */
-    outputFormat?: "text" | "json" | "markdown";
-}
-/**
- * Abstract document loader interface
- */
-export interface DocumentLoader {
-    /**
-     * Load document from source
-     * @param source - File path, URL, or content
-     * @param options - Loader options
-     * @returns Promise resolving to MDocument
-     */
-    load(source: string, options?: LoaderOptions): Promise<MDocument>;
-    /**
-     * Check if loader can handle the source
-     * @param source - File path, URL, or content
-     * @returns True if loader can handle the source
-     */
-    canHandle(source: string): boolean;
-}
+import type { LoaderOptions, WebLoaderOptions, PDFLoaderOptions, CSVLoaderOptions, DocumentLoader } from "../../types/ragTypes.js";
+export type { LoaderOptions } from "../../types/ragTypes.js";
+export type { WebLoaderOptions } from "../../types/ragTypes.js";
+export type { PDFLoaderOptions } from "../../types/ragTypes.js";
+export type { CSVLoaderOptions } from "../../types/ragTypes.js";
+export type { DocumentLoader } from "../../types/ragTypes.js";
 /**
  * Text file loader
  */

package/dist/rag/document/loaders.js

@@ -23,11 +23,11 @@
  * const pdfDoc = await PDFLoader.load('/path/to/document.pdf');
  * ```
  */
-import { readFile } from "fs/promises";
 import { existsSync } from "fs";
-import { extname, basename } from "path";
-import { MDocument } from "./MDocument.js";
+import { readFile } from "fs/promises";
+import { basename, extname } from "path";
 import { logger } from "../../utils/logger.js";
+import { MDocument } from "./MDocument.js";
 /**
  * Text file loader
  */
@@ -244,8 +244,8 @@ export class PDFLoader {
     }
     async loadPdfParser() {
         try {
-            // @ts-expect-error pdf-parse is an optional dependency
-            const pdfParse = await import("pdf-parse");
+            // pdf-parse is an optional dependency - use dynamic import with type assertion
+            const pdfParse = (await import("pdf-parse"));
             return pdfParse.default || pdfParse;
         }
         catch {

package/dist/rag/graphRag/graphRAG.js

@@ -52,11 +52,17 @@ export class GraphRAG {
         for (let i = 0; i < nodeIds.length; i++) {
             const edges = [];
             const nodeA = this.nodes.get(nodeIds[i]);
+            if (!nodeA?.embedding) {
+                continue;
+            }
             for (let j = 0; j < nodeIds.length; j++) {
                 if (i === j) {
                     continue;
                 }
                 const nodeB = this.nodes.get(nodeIds[j]);
+                if (!nodeB?.embedding) {
+                    continue;
+                }
                 const similarity = this.cosineSimilarity(nodeA.embedding, nodeB.embedding);
                 if (similarity >= this.threshold) {
                     edges.push({
@@ -137,14 +143,19 @@ export class GraphRAG {
         const rankedNodes = Array.from(scores.entries())
             .sort((a, b) => b[1] - a[1])
             .slice(0, topK)
-            .map(([id, score]) => {
+            .flatMap(([id, score]) => {
             const node = this.nodes.get(id);
-            return {
-                id,
-                content: node.content,
-                metadata: node.metadata,
-                score,
-            };
+            if (!node) {
+                return [];
+            }
+            return [
+                {
+                    id,
+                    content: node.content,
+                    metadata: node.metadata,
+                    score,
+                },
+            ];
         });
         logger.debug("[GraphRAG] Query completed", {
             topK,
@@ -174,6 +185,9 @@ export class GraphRAG {
             if (existingId === id) {
                 continue;
             }
+            if (!existingNode.embedding) {
+                continue;
+            }
             const similarity = this.cosineSimilarity(embedding.vector, existingNode.embedding);
             if (similarity >= this.threshold) {
                 edges.push({
@@ -259,7 +273,7 @@ export class GraphRAG {
             const queue = [nodeId];
             while (queue.length > 0) {
                 const current = queue.shift();
-                if (visited.has(current)) {
+                if (current === undefined || visited.has(current)) {
                     continue;
                 }
                 visited.add(current);
@@ -327,12 +341,15 @@ export class GraphRAG {
         for (let i = 0; i < nodeIds.length; i++) {
             const edges = [];
             const nodeA = this.nodes.get(nodeIds[i]);
+            if (!nodeA?.embedding) {
+                continue;
+            }
             for (let j = 0; j < nodeIds.length; j++) {
                 if (i === j) {
                     continue;
                 }
                 const nodeB = this.nodes.get(nodeIds[j]);
-                if (!nodeA.embedding || !nodeB.embedding) {
+                if (!nodeB?.embedding) {
                     continue;
                 }
                 const similarity = this.cosineSimilarity(nodeA.embedding, nodeB.embedding);

package/dist/rag/metadata/MetadataExtractorFactory.d.ts

@@ -5,61 +5,11 @@
  * Follows the BaseFactory pattern for consistent lifecycle management.
  */
 import { BaseFactory } from "../../core/infrastructure/index.js";
-import type { Chunk, ExtractionResult, ExtractParams } from "../types.js";
-/**
- * Supported metadata extractor types
- */
-export type MetadataExtractorType = "llm" | "title" | "summary" | "keywords" | "questions" | "custom" | "composite";
-/**
- * Metadata Extractor interface - all extractors implement this
- */
-export interface MetadataExtractor {
-    /** Extractor type identifier */
-    readonly type: MetadataExtractorType;
-    /**
-     * Extract metadata from chunks
-     * @param chunks - Array of chunks to extract metadata from
-     * @param params - Extraction parameters
-     * @returns Array of extraction results
-     */
-    extract(chunks: Chunk[], params?: ExtractParams): Promise<ExtractionResult[]>;
-}
-/**
- * Metadata extractor configuration
- */
-export interface MetadataExtractorConfig {
-    /** Extractor type */
-    type: MetadataExtractorType;
-    /** Language model provider */
-    provider?: string;
-    /** Model name for LLM-based extraction */
-    modelName?: string;
-    /** Custom prompt template */
-    promptTemplate?: string;
-    /** Maximum tokens for LLM response */
-    maxTokens?: number;
-    /** Temperature for LLM generation */
-    temperature?: number;
-}
-/**
- * Metadata extractor metadata for discovery and documentation
- */
-export interface MetadataExtractorMetadata {
-    /** Human-readable description */
-    description: string;
-    /** Default configuration */
-    defaultConfig: Partial<MetadataExtractorConfig>;
-    /** Supported configuration options */
-    supportedOptions: string[];
-    /** Recommended use cases */
-    useCases: string[];
-    /** Alternative names for this extractor */
-    aliases: string[];
-    /** Whether this extractor requires an AI model */
-    requiresModel: boolean;
-    /** Extraction types this extractor can produce */
-    extractionTypes: string[];
-}
+import type { MetadataExtractor, MetadataExtractorConfig, MetadataExtractorMetadata, MetadataExtractorType } from "../../types/ragTypes.js";
+export type { MetadataExtractorType } from "../../types/ragTypes.js";
+export type { MetadataExtractor } from "../../types/ragTypes.js";
+export type { MetadataExtractorConfig } from "../../types/ragTypes.js";
+export type { MetadataExtractorMetadata } from "../../types/ragTypes.js";
 /**
  * Metadata Extractor Factory
  *

package/dist/rag/metadata/metadataExtractor.js

@@ -113,10 +113,13 @@ export class LLMMetadataExtractor {
         const groups = new Map();
         for (const chunk of chunks) {
             const docId = chunk.metadata.documentId;
-            if (!groups.has(docId)) {
-                groups.set(docId, []);
+            const group = groups.get(docId);
+            if (group) {
+                group.push(chunk);
+            }
+            else {
+                groups.set(docId, [chunk]);
             }
-            groups.get(docId).push(chunk);
         }
         return groups;
     }

package/dist/rag/pipeline/RAGPipeline.d.ts

@@ -25,133 +25,15 @@
  * console.log(response.answer, response.sources);
  * ```
  */
-import type { ChunkingStrategy } from "../types.js";
 import { MDocument } from "../document/MDocument.js";
-import { type VectorStore } from "../retrieval/vectorQueryTool.js";
-import { type BM25Index } from "../retrieval/hybridSearch.js";
-/**
- * Embedding model configuration
- */
-export interface EmbeddingModelConfig {
-    provider: string;
-    modelName: string;
-}
-/**
- * Generation model configuration
- */
-export interface GenerationModelConfig {
-    provider: string;
-    modelName: string;
-    temperature?: number;
-    maxTokens?: number;
-}
-/**
- * RAG pipeline configuration
- */
-export interface RAGPipelineConfig {
-    /** Pipeline identifier */
-    id?: string;
-    /** Vector store instance (defaults to in-memory) */
-    vectorStore?: VectorStore;
-    /** BM25 index for hybrid search (defaults to in-memory) */
-    bm25Index?: BM25Index;
-    /** Index name for vector store */
-    indexName?: string;
-    /** Embedding model configuration */
-    embeddingModel: EmbeddingModelConfig;
-    /** Generation model configuration (for RAG responses) */
-    generationModel?: GenerationModelConfig;
-    /** Default chunking strategy */
-    defaultChunkingStrategy?: ChunkingStrategy;
-    /** Default chunk size */
-    defaultChunkSize?: number;
-    /** Default chunk overlap */
-    defaultChunkOverlap?: number;
-    /** Enable hybrid search (vector + BM25) */
-    enableHybridSearch?: boolean;
-    /** Enable Graph RAG */
-    enableGraphRAG?: boolean;
-    /** Graph RAG similarity threshold */
-    graphThreshold?: number;
-    /** Default number of results to retrieve */
-    defaultTopK?: number;
-    /** Enable reranking */
-    enableReranking?: boolean;
-    /** Reranking model configuration */
-    rerankingModel?: EmbeddingModelConfig;
-}
-/**
- * Ingestion options
- */
-export interface IngestOptions {
-    /** Chunking strategy override */
-    strategy?: ChunkingStrategy;
-    /** Chunk size override */
-    chunkSize?: number;
-    /** Chunk overlap override */
-    chunkOverlap?: number;
-    /** Custom metadata to add */
-    metadata?: Record<string, unknown>;
-    /** Extract metadata using LLM */
-    extractMetadata?: boolean;
-}
-/**
- * Query options
- */
-export interface QueryOptions {
-    /** Number of chunks to retrieve */
-    topK?: number;
-    /** Use hybrid search */
-    hybrid?: boolean;
-    /** Use Graph RAG */
-    graph?: boolean;
-    /** Enable reranking */
-    rerank?: boolean;
-    /** Metadata filter */
-    filter?: Record<string, unknown>;
-    /** Include sources in response */
-    includeSources?: boolean;
-    /** Generate response (vs just retrieve) */
-    generate?: boolean;
-    /** Custom system prompt for generation */
-    systemPrompt?: string;
-    /** Temperature for generation */
-    temperature?: number;
-}
-/**
- * Query response
- */
-export interface RAGResponse {
-    /** Generated answer (if generate=true) */
-    answer?: string;
-    /** Retrieved context chunks */
-    context: string;
-    /** Source documents/chunks */
-    sources: Array<{
-        id: string;
-        text: string;
-        score: number;
-        metadata?: Record<string, unknown>;
-    }>;
-    /** Query metadata */
-    metadata: {
-        queryTime: number;
-        retrievalMethod: string;
-        chunksRetrieved: number;
-        reranked: boolean;
-    };
-}
-/**
- * Pipeline statistics
- */
-export interface PipelineStats {
-    totalDocuments: number;
-    totalChunks: number;
-    indexName: string;
-    embeddingDimension?: number;
-    hybridSearchEnabled: boolean;
-    graphRAGEnabled: boolean;
-}
+import type { RAGPipelineConfig, IngestOptions, QueryOptions, RAGResponse, PipelineStats } from "../../types/ragTypes.js";
+export type { EmbeddingModelConfig } from "../../types/ragTypes.js";
+export type { GenerationModelConfig } from "../../types/ragTypes.js";
+export type { RAGPipelineConfig } from "../../types/ragTypes.js";
+export type { IngestOptions } from "../../types/ragTypes.js";
+export type { QueryOptions } from "../../types/ragTypes.js";
+export type { RAGResponse } from "../../types/ragTypes.js";
+export type { PipelineStats } from "../../types/ragTypes.js";
 /**
  * RAG Pipeline Orchestrator
  *

package/dist/rag/pipeline/RAGPipeline.js

@@ -89,7 +89,7 @@ export class RAGPipeline {
             this.hybridSearch = createHybridSearch({
                 vectorStore: this.vectorStore,
                 bm25Index: this.bm25Index,
-                indexName: this.config.indexName,
+                indexName: this.config.indexName ?? "default",
                 embeddingModel: this.config.embeddingModel,
             });
         }
@@ -103,9 +103,9 @@ export class RAGPipeline {
      */
     async ingest(sources, options) {
         await this.ensureInitialized();
-        const strategy = options?.strategy || this.config.defaultChunkingStrategy;
-        const chunkSize = options?.chunkSize || this.config.defaultChunkSize;
-        const chunkOverlap = options?.chunkOverlap || this.config.defaultChunkOverlap;
+        const strategy = options?.strategy || this.config.defaultChunkingStrategy || "recursive";
+        const chunkSize = options?.chunkSize || this.config.defaultChunkSize || 1000;
+        const chunkOverlap = options?.chunkOverlap || this.config.defaultChunkOverlap || 200;
         let documentsProcessed = 0;
         let chunksCreated = 0;
         for (const source of sources) {
@@ -137,13 +137,13 @@ export class RAGPipeline {
                 const embeddings = doc.getEmbeddings();
                 // Store in vector store
                 await this.vectorStore.query({
-                    indexName: this.config.indexName,
+                    indexName: this.config.indexName ?? "default",
                     queryVector: embeddings[0],
                     topK: 1,
                 }); // Warm up
                 // Upsert into vector store
                 if ("upsert" in this.vectorStore) {
-                    await this.vectorStore.upsert(this.config.indexName, chunks.map((chunk, i) => ({
+                    await this.vectorStore.upsert(this.config.indexName ?? "default", chunks.map((chunk, i) => ({
                         id: chunk.id,
                         vector: embeddings[i],
                         metadata: { ...chunk.metadata, text: chunk.text },
@@ -197,7 +197,7 @@ export class RAGPipeline {
     async query(query, options) {
         await this.ensureInitialized();
         const startTime = Date.now();
-        const topK = options?.topK || this.config.defaultTopK;
+        const topK = options?.topK || this.config.defaultTopK || 5;
         const useHybrid = options?.hybrid ?? this.config.enableHybridSearch;
         const useGraph = options?.graph ?? this.config.enableGraphRAG;
         const useRerank = options?.rerank ?? this.config.enableReranking;
@@ -233,7 +233,7 @@ export class RAGPipeline {
         else {
             // Vector search
             results = await this.vectorStore.query({
-                indexName: this.config.indexName,
+                indexName: this.config.indexName ?? "default",
                 queryVector: queryEmbedding,
                 topK: topK * 2,
                 filter: options?.filter,
@@ -293,10 +293,10 @@ export class RAGPipeline {
         return {
             totalDocuments: this.documents.size,
             totalChunks: this.allChunks.length,
-            indexName: this.config.indexName,
+            indexName: this.config.indexName ?? "default",
             embeddingDimension: this.allChunks[0]?.embedding?.length,
-            hybridSearchEnabled: this.config.enableHybridSearch,
-            graphRAGEnabled: this.config.enableGraphRAG,
+            hybridSearchEnabled: this.config.enableHybridSearch ?? false,
+            graphRAGEnabled: this.config.enableGraphRAG ?? false,
         };
     }
     /**

package/dist/rag/pipeline/contextAssembly.d.ts

@@ -12,52 +12,13 @@
  * - Context summarization
  */
 import type { Chunk, VectorQueryResult } from "../types.js";
+import type { ContextAssemblyOptions, ContextWindow } from "../../types/ragTypes.js";
 /**
  * Citation format options
  */
 export type CitationFormat = "inline" | "footnote" | "numbered" | "none";
-/**
- * Context assembly options
- */
-export interface ContextAssemblyOptions {
-    /** Maximum characters in assembled context */
-    maxChars?: number;
-    /** Maximum tokens (approximate, 4 chars/token) */
-    maxTokens?: number;
-    /** Citation format to use */
-    citationFormat?: CitationFormat;
-    /** Separator between chunks */
-    separator?: string;
-    /** Include chunk metadata in context */
-    includeMetadata?: boolean;
-    /** Deduplicate overlapping content */
-    deduplicate?: boolean;
-    /** Similarity threshold for deduplication (0-1) */
-    dedupeThreshold?: number;
-    /** Order by relevance score */
-    orderByRelevance?: boolean;
-    /** Include section headers */
-    includeSectionHeaders?: boolean;
-    /** Header template (use {index}, {source}, {score} placeholders) */
-    headerTemplate?: string;
-}
-/**
- * Context window representation
- */
-export interface ContextWindow {
-    /** Assembled context text */
-    text: string;
-    /** Number of chunks included */
-    chunkCount: number;
-    /** Total character count */
-    charCount: number;
-    /** Estimated token count */
-    tokenCount: number;
-    /** Chunks that were truncated/excluded */
-    truncatedChunks: number;
-    /** Citation map (id -> citation text) */
-    citations: Map<string, string>;
-}
+export type { ContextAssemblyOptions } from "../../types/ragTypes.js";
+export type { ContextWindow } from "../../types/ragTypes.js";
 /**
  * Assemble context from retrieved results
  *