@juspay/neurolink 9.5.3 → 9.7.0

package/dist/providers/huggingFace.js

@@ -3,7 +3,7 @@ import { streamText, } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createHuggingFaceConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
@@ -112,20 +112,35 @@ export class HuggingFaceProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools - options.tools is pre-merged by BaseProvider.stream()
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const allTools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
             // Enhanced tool handling for HuggingFace models
             const streamOptions = this.prepareStreamOptions(options, analysisSchema);
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
-            const messages = await this.buildMessagesForStream(options);
+            // Pass the enhanced system prompt (with tool-calling instructions) so it
+            // actually reaches the model instead of being silently discarded.
+            const messagesOptions = streamOptions.system
+                ? { ...options, systemPrompt: streamOptions.system }
+                : options;
+            const messages = await this.buildMessagesForStream(messagesOptions);
             const result = await streamText({
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions
-                toolChoice: streamOptions.toolChoice, // Tool choice handled by prepareStreamOptions
-                abortSignal: timeoutController?.controller.signal,
+                tools: (shouldUseTools
+                    ? streamOptions.tools || allTools
+                    : {}),
+                toolChoice: (shouldUseTools
+                    ? streamOptions.toolChoice || "auto"
+                    : "none"),
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[HuggingFaceProvider] Failed to store tool executions", {

package/dist/providers/litellm.js

@@ -4,9 +4,10 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { getProviderModel } from "../utils/providerConfig.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Configuration helpers
 const getLiteLLMConfig = () => {
     return {
@@ -157,7 +158,8 @@ export class LiteLLMProvider extends BaseProvider {
                     toolChoice: "auto",
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -180,7 +182,7 @@ export class LiteLLMProvider extends BaseProvider {
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                        logger.warn("LiteLLMProvider] Failed to store tool executions", {
+                        logger.warn("[LiteLLMProvider] Failed to store tool executions", {
                             provider: this.providerName,
                             error: error instanceof Error ? error.message : String(error),
                         });
@@ -361,7 +363,7 @@ export class LiteLLMProvider extends BaseProvider {
         }
         catch (error) {
             clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === "AbortError") {
+            if (isAbortError(error)) {
                 throw new Error("Request timed out after 5 seconds");
             }
             throw error;

package/dist/providers/mistral.js

@@ -6,7 +6,7 @@ import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { logger } from "../utils/logger.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Configuration helpers - now using consolidated utility
 const getMistralApiKey = () => {
     return validateApiKey(createMistralConfig());
@@ -63,7 +63,8 @@ export class MistralProvider extends BaseProvider {
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[MistralProvider] Failed to store tool executions", {

package/dist/providers/openAI.js

@@ -9,7 +9,7 @@ import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, Ra
 import { logger } from "../utils/logger.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Configuration helpers - now using consolidated utility
 const getOpenAIApiKey = () => {
     return validateApiKey(createOpenAIConfig());
@@ -282,7 +282,7 @@ export class OpenAIProvider extends BaseProvider {
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });

package/dist/providers/openRouter.js

@@ -1,13 +1,14 @@
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { Output, streamText } from "ai";
+import { Output, streamText, } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { getProviderModel } from "../utils/providerConfig.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Constants
 const MODELS_DISCOVERY_TIMEOUT_MS = 5000; // 5 seconds for model discovery
 // Configuration helpers
@@ -206,8 +207,7 @@ export class OpenRouterProvider extends BaseProvider {
             // BaseProvider.stream() pre-merges base tools + external tools into options.tools
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools
-                ? options.tools ||
-                    (await this.getAllTools())
+                ? options.tools || (await this.getAllTools())
                 : {};
             logger.debug(`OpenRouter: Tools for streaming`, {
                 shouldUseTools,
@@ -229,7 +229,8 @@ export class OpenRouterProvider extends BaseProvider {
                     toolChoice: "auto",
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -276,7 +277,7 @@ export class OpenRouterProvider extends BaseProvider {
                 }
             }
             const result = await streamText(streamOptions);
-            timeoutController?.cleanup();
+            result.text.finally(() => timeoutController?.cleanup());
             // Transform stream to content object stream using fullStream (handles both text and tool calls)
             const transformedStream = (async function* () {
                 // Try fullStream first (handles both text and tool calls), fallback to textStream
@@ -439,7 +440,7 @@ export class OpenRouterProvider extends BaseProvider {
         }
         catch (error) {
             clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === "AbortError") {
+            if (isAbortError(error)) {
                 throw new Error(`Request timed out after ${MODELS_DISCOVERY_TIMEOUT_MS / 1000} seconds`);
             }
             throw error;

package/dist/providers/openaiCompatible.js

@@ -3,7 +3,7 @@ import { streamText } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
@@ -159,6 +159,11 @@ export class OpenAICompatibleProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools - options.tools is pre-merged by BaseProvider.stream()
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
@@ -173,9 +178,10 @@ export class OpenAICompatibleProvider extends BaseProvider {
                     ? { temperature: options.temperature }
                     : {}),
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                tools: options.tools,
-                toolChoice: "auto",
-                abortSignal: timeoutController?.controller.signal,
+                tools,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {

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;
     }