@juspay/neurolink 9.5.2 → 9.6.0

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