@juspay/neurolink 9.5.3 → 9.7.0

package/dist/lib/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/lib/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/lib/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
  *

package/dist/lib/rag/pipeline/contextAssembly.js

@@ -307,10 +307,13 @@ export function orderByDocumentStructure(chunks) {
     const byDocument = new Map();
     for (const chunk of chunks) {
         const docId = chunk.metadata.documentId;
-        if (!byDocument.has(docId)) {
-            byDocument.set(docId, []);
+        const group = byDocument.get(docId);
+        if (group) {
+            group.push(chunk);
+        }
+        else {
+            byDocument.set(docId, [chunk]);
         }
-        byDocument.get(docId).push(chunk);
     }
     // Sort each document's chunks by position
     for (const docChunks of byDocument.values()) {

package/dist/lib/rag/reranker/RerankerFactory.d.ts

@@ -6,66 +6,11 @@
  */
 import { BaseFactory } from "../../core/infrastructure/index.js";
 import type { AIProvider } from "../../types/providers.js";
-import type { RerankerOptions, RerankResult, VectorQueryResult } from "../types.js";
-/**
- * Supported reranker types
- */
-export type RerankerType = "llm" | "cross-encoder" | "cohere" | "simple" | "batch";
-/**
- * Reranker interface - all rerankers implement this
- */
-export interface Reranker {
-    /** Reranker type identifier */
-    readonly type: RerankerType;
-    /**
-     * Rerank results based on query relevance
-     * @param results - Vector search results to rerank
-     * @param query - Original search query
-     * @param options - Reranking options
-     * @returns Reranked results with scores
-     */
-    rerank(results: VectorQueryResult[], query: string, options?: RerankerOptions): Promise<RerankResult[]>;
-}
-/**
- * Reranker configuration
- */
-export interface RerankerConfig {
-    /** Reranker type */
-    type: RerankerType;
-    /** Model name for LLM-based rerankers */
-    model?: string;
-    /** Provider for the model */
-    provider?: string;
-    /** Number of results to return after reranking */
-    topK?: number;
-    /** Scoring weights */
-    weights?: {
-        semantic?: number;
-        vector?: number;
-        position?: number;
-    };
-    /** API key for external services (e.g., Cohere) */
-    apiKey?: string;
-}
-/**
- * Reranker metadata for discovery and documentation
- */
-export interface RerankerMetadata {
-    /** Human-readable description */
-    description: string;
-    /** Default configuration */
-    defaultConfig: Partial<RerankerConfig>;
-    /** Supported configuration options */
-    supportedOptions: string[];
-    /** Recommended use cases */
-    useCases: string[];
-    /** Alternative names for this reranker */
-    aliases: string[];
-    /** Whether this reranker requires an AI model */
-    requiresModel: boolean;
-    /** Whether this reranker requires external API */
-    requiresExternalAPI: boolean;
-}
+import type { Reranker, RerankerConfig, RerankerMetadata, RerankerType } from "../../types/ragTypes.js";
+export type { RerankerType } from "../../types/ragTypes.js";
+export type { Reranker } from "../../types/ragTypes.js";
+export type { RerankerConfig } from "../../types/ragTypes.js";
+export type { RerankerMetadata } from "../../types/ragTypes.js";
 /**
  * Reranker Factory
  *

package/dist/lib/rag/resilience/CircuitBreaker.d.ts

@@ -10,39 +10,9 @@ import { TypedEventEmitter } from "../../core/infrastructure/index.js";
  * Circuit breaker states
  */
 export type CircuitState = "closed" | "open" | "half-open";
-/**
- * Circuit breaker configuration
- */
-export interface RAGCircuitBreakerConfig {
-    /** Number of failures before opening circuit (default: 5) */
-    failureThreshold: number;
-    /** Time in ms before attempting reset (default: 60000) */
-    resetTimeout: number;
-    /** Max calls allowed in half-open state (default: 3) */
-    halfOpenMaxCalls: number;
-    /** Operation timeout in ms (default: 30000) */
-    operationTimeout: number;
-    /** Minimum calls before calculating failure rate (default: 10) */
-    minimumCallsBeforeCalculation: number;
-    /** Time window for statistics in ms (default: 300000 - 5 minutes) */
-    statisticsWindowSize: number;
-}
-/**
- * Circuit breaker statistics
- */
-export interface RAGCircuitBreakerStats {
-    state: CircuitState;
-    totalCalls: number;
-    successfulCalls: number;
-    failedCalls: number;
-    failureRate: number;
-    windowCalls: number;
-    lastStateChange: Date;
-    nextRetryTime?: Date;
-    halfOpenCalls: number;
-    averageLatency: number;
-    p95Latency: number;
-}
+import type { RAGCircuitBreakerConfig, RAGCircuitBreakerStats } from "../../types/ragTypes.js";
+export type { RAGCircuitBreakerConfig } from "../../types/ragTypes.js";
+export type { RAGCircuitBreakerStats } from "../../types/ragTypes.js";
 /**
  * Circuit breaker events
  */

package/dist/lib/rag/resilience/RetryHandler.d.ts

@@ -5,27 +5,8 @@
  * specifically designed for RAG operations including embeddings,
  * vector queries, and LLM-based extraction.
  */
-/**
- * RAG-specific retry configuration
- */
-export interface RAGRetryConfig {
-    /** Maximum number of retry attempts (default: 3) */
-    maxRetries: number;
-    /** Initial delay in ms (default: 1000) */
-    initialDelay: number;
-    /** Maximum delay in ms (default: 30000) */
-    maxDelay: number;
-    /** Backoff multiplier (default: 2) */
-    backoffMultiplier: number;
-    /** Whether to add jitter (default: true) */
-    jitter: boolean;
-    /** Custom function to determine if error is retryable */
-    shouldRetry?: (error: Error) => boolean;
-    /** Retryable error codes */
-    retryableErrorCodes?: string[];
-    /** Retryable HTTP status codes */
-    retryableStatusCodes?: number[];
-}
+import type { RAGRetryConfig } from "../../types/ragTypes.js";
+export type { RAGRetryConfig } from "../../types/ragTypes.js";
 /**
  * Default retry configuration
  */

package/dist/lib/rag/resilience/RetryHandler.js

@@ -6,6 +6,7 @@
  * vector queries, and LLM-based extraction.
  */
 import { withRetry, } from "../../core/infrastructure/index.js";
+import { isAbortError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { EmbeddingError, isRetryableRAGError, MetadataExtractionError, RAGError, RAGErrorCodes, VectorQueryError, } from "../errors/RAGError.js";
 /**
@@ -50,6 +51,10 @@ function sleep(ms) {
  * Check if an error is retryable based on configuration
  */
 export function isRetryable(error, config = DEFAULT_RAG_RETRY_CONFIG) {
+    // Never retry abort errors - the operation was intentionally cancelled
+    if (isAbortError(error)) {
+        return false;
+    }
     // Use custom shouldRetry if provided
     if (config.shouldRetry) {
         return config.shouldRetry(error);
@@ -70,8 +75,7 @@ export function isRetryable(error, config = DEFAULT_RAG_RETRY_CONFIG) {
         // Timeout errors
         if (errorObj.name === "TimeoutError" ||
             errorObj.code === "TIMEOUT" ||
-            errorObj.code === "ETIMEDOUT" ||
-            errorObj.name === "AbortError") {
+            errorObj.code === "ETIMEDOUT") {
             return true;
         }
         // Network errors

package/dist/lib/rag/retrieval/hybridSearch.d.ts

@@ -5,29 +5,8 @@
  * Supports multiple fusion methods: Reciprocal Rank Fusion (RRF) and Linear Combination.
  */
 import type { BM25Result, HybridSearchConfig, HybridSearchResult } from "../types.js";
-import type { VectorStore } from "./vectorQueryTool.js";
-/**
- * BM25 Index interface
- * Implementations should provide sparse retrieval capabilities
- */
-export interface BM25Index {
-    /**
-     * Search documents using BM25 algorithm
-     * @param query - Search query string
-     * @param topK - Number of results to return
-     * @returns Array of BM25 results
-     */
-    search(query: string, topK?: number): Promise<BM25Result[]>;
-    /**
-     * Add documents to the index
-     * @param documents - Documents to index
-     */
-    addDocuments(documents: Array<{
-        id: string;
-        text: string;
-        metadata?: Record<string, unknown>;
-    }>): Promise<void>;
-}
+import type { BM25Index, HybridSearchOptions } from "../../types/ragTypes.js";
+export type { BM25Index } from "../../types/ragTypes.js";
 /**
  * In-memory BM25 implementation for testing and development
  */
@@ -67,24 +46,7 @@ export declare function reciprocalRankFusion(rankings: Array<Array<{
  * @returns Map of document IDs to combined scores
  */
 export declare function linearCombination(vectorScores: Map<string, number>, bm25Scores: Map<string, number>, alpha?: number): Map<string, number>;
-/**
- * Hybrid search configuration for creating a search function
- */
-export interface HybridSearchOptions {
-    /** Vector store instance */
-    vectorStore: VectorStore;
-    /** BM25 index instance */
-    bm25Index: BM25Index;
-    /** Index name for vector store */
-    indexName: string;
-    /** Embedding model configuration (optional - uses defaults from ProviderFactory if not specified) */
-    embeddingModel?: {
-        provider?: string;
-        modelName?: string;
-    };
-    /** Default search configuration */
-    defaultConfig?: HybridSearchConfig;
-}
+export type { HybridSearchOptions } from "../../types/ragTypes.js";
 /**
  * Create a hybrid search function
  *

package/dist/lib/rag/retrieval/vectorQueryTool.d.ts

@@ -6,19 +6,8 @@
  */
 import { z } from "zod";
 import type { MetadataFilter, RequestContext, VectorQueryResponse, VectorQueryResult, VectorQueryToolConfig } from "../types.js";
-/**
- * Abstract vector store interface
- * Vector stores should implement this interface to work with the query tool
- */
-export interface VectorStore {
-    query(params: {
-        indexName: string;
-        queryVector: number[];
-        topK?: number;
-        filter?: MetadataFilter;
-        includeVectors?: boolean;
-    }): Promise<VectorQueryResult[]>;
-}
+import type { VectorStore } from "../../types/ragTypes.js";
+export type { VectorStore } from "../../types/ragTypes.js";
 /**
  * Creates a vector query tool for semantic search
  * Follows NeuroLink's factory pattern

package/dist/lib/rag/retrieval/vectorQueryTool.js

@@ -123,10 +123,11 @@ export class InMemoryVectorStore {
      * Add vectors to an index
      */
     async upsert(indexName, items) {
-        if (!this.vectors.has(indexName)) {
-            this.vectors.set(indexName, new Map());
+        let index = this.vectors.get(indexName);
+        if (!index) {
+            index = new Map();
+            this.vectors.set(indexName, index);
         }
-        const index = this.vectors.get(indexName);
         for (const item of items) {
             index.set(item.id, {
                 vector: item.vector,

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

@@ -211,9 +211,9 @@ export type SemanticChunkerConfig = BaseChunkerConfig & {
  */
 export type ChunkerConfig = CharacterChunkerConfig | RecursiveChunkerConfig | SentenceChunkerConfig | TokenChunkerConfig | MarkdownChunkerConfig | HTMLChunkerConfig | JSONChunkerConfig | LaTeXChunkerConfig | SemanticChunkerConfig;
 /**
- * Chunker interface - all chunking strategies implement this
+ * Chunker type - all chunking strategies implement this
  */
-export interface Chunker {
+export type Chunker = {
     /** Strategy name for identification */
     readonly strategy: ChunkingStrategy;
     /**
@@ -223,7 +223,7 @@ export interface Chunker {
      * @returns Array of chunks
      */
     chunk(text: string, config?: BaseChunkerConfig): Promise<Chunk[]>;
-}
+};
 /**
  * Chunker metadata for factory registration
  */

package/dist/lib/sdk/toolRegistration.d.ts

@@ -27,7 +27,7 @@ export type ToolContext = SDKToolContext;
  * Simple tool interface for SDK users
  * Extends the core SimpleTool with specific types
  */
-export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> extends Omit<CoreSimpleTool<TArgs, TResult>, "execute"> {
+export type SimpleTool<TArgs = ToolArgs, TResult = JsonValue> = Omit<CoreSimpleTool<TArgs, TResult>, "execute"> & {
     /**
      * Tool description that helps AI understand when to use it
      */
@@ -51,7 +51,7 @@ export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> extends Omit<
         documentation?: string;
         [key: string]: JsonValue | undefined;
     };
-}
+};
 /**
  * Creates a MCPServerInfo from a set of tools
  */

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

@@ -55,12 +55,12 @@ export type CacheEntry = {
 /**
  * Cache store interface
  */
-export interface CacheStore {
+export type CacheStore = {
     get(key: string): Promise<CacheEntry | undefined>;
     set(key: string, entry: CacheEntry): Promise<void>;
     delete(key: string): Promise<void>;
     clear(): Promise<void>;
-}
+};
 /**
  * In-memory LRU cache store
  */

package/dist/lib/server/middleware/rateLimit.d.ts

@@ -41,7 +41,7 @@ export type RateLimitEntry = {
  * Rate limit store interface
  * Implement this for custom storage (Redis, etc.)
  */
-export interface RateLimitStore {
+export type RateLimitStore = {
     /**
      * Get the current entry for a key
      */
@@ -59,7 +59,7 @@ export interface RateLimitStore {
      * Reset the counter for a key
      */
     reset(key: string): Promise<void>;
-}
+};
 /**
  * In-memory rate limit store
  */