@retrivora-ai/rag-engine 1.0.3 → 1.0.5

package/dist/handlers/index.js

@@ -1508,7 +1508,11 @@ __export(handlers_exports, {
   createHealthHandler: () => createHealthHandler,
   createIngestHandler: () => createIngestHandler,
   createStreamHandler: () => createStreamHandler,
-  createUploadHandler: () => createUploadHandler
+  createUploadHandler: () => createUploadHandler,
+  sseErrorFrame: () => sseErrorFrame,
+  sseFrame: () => sseFrame,
+  sseMetaFrame: () => sseMetaFrame,
+  sseTextFrame: () => sseTextFrame
 });
 module.exports = __toCommonJS(handlers_exports);
 var import_server = require("next/server");
@@ -1691,13 +1695,20 @@ function getRagConfig(env = process.env) {
 }
 
 // src/core/ConfigResolver.ts
+var _cachedEnvConfig = null;
+function getCachedEnvConfig() {
+  if (!_cachedEnvConfig) {
+    _cachedEnvConfig = getRagConfig();
+  }
+  return _cachedEnvConfig;
+}
 var ConfigResolver = class {
   /**
-   * Resolves the final configuration by merging host-provided config with defaults.
+   * Resolves the final configuration by merging host-provided config with environment defaults.
    * @param hostConfig - Partial configuration passed from the host application.
    */
   static resolve(hostConfig) {
-    const envConfig = getRagConfig();
+    const envConfig = getCachedEnvConfig();
     if (!hostConfig) {
       return envConfig;
     }
@@ -2871,25 +2882,42 @@ Text to extract from:
     const response = await this.llm.chat([
       { role: "system", content: "You are a precise knowledge graph extraction engine. You always output valid JSON and nothing else." },
       { role: "user", content: prompt }
-    ], "", { maxTokens: 2048, temperature: 0.1 });
+    ], "", { maxTokens: 4096, temperature: 0.1 });
     try {
       const jsonMatch = response.match(/\{[\s\S]*\}/);
       const cleanJson = jsonMatch ? jsonMatch[0] : response.trim();
       return JSON.parse(cleanJson);
     } catch (e) {
-      console.warn(`[EntityExtractor] Failed to parse LLM response. Length: ${response.length} chars.`);
-      if (response.trim().endsWith("}") === false && response.includes('"nodes"')) {
-        try {
-          const partialResponse = response.trim() + (response.includes("[") ? "]}" : "}");
-          const jsonMatch = partialResponse.match(/\{[\s\S]*\}/);
-          if (jsonMatch) return JSON.parse(jsonMatch[0]);
-        } catch (e2) {
-        }
+      try {
+        const repaired = this.repairTruncatedJson(response);
+        if (repaired) return JSON.parse(repaired);
+      } catch (e2) {
       }
-      console.warn("[EntityExtractor] Full failing response:", response.substring(0, 200) + "...");
+      console.warn(`[EntityExtractor] Failed to parse LLM response. Length: ${response.length} chars.`);
+      console.warn("[EntityExtractor] Snippet:", response.substring(0, 100) + "...");
       return { nodes: [], edges: [] };
     }
   }
+  /**
+   * Attempts to fix JSON that was cut off mid-generation.
+   * Strategy: Find the last valid element in an array and close the structure.
+   */
+  repairTruncatedJson(json) {
+    let text = json.trim();
+    const startIdx = text.indexOf("{");
+    if (startIdx === -1) return null;
+    text = text.substring(startIdx);
+    const lastCompleteObjectIdx = text.lastIndexOf("}");
+    if (lastCompleteObjectIdx === -1) return null;
+    let repaired = text.substring(0, lastCompleteObjectIdx + 1);
+    const openBrackets = (repaired.match(/\{/g) || []).length;
+    const closedBrackets = (repaired.match(/\}/g) || []).length;
+    const openSquares = (repaired.match(/\[/g) || []).length;
+    const closedSquares = (repaired.match(/\]/g) || []).length;
+    for (let i = 0; i < openSquares - closedSquares; i++) repaired += "]";
+    for (let i = 0; i < openBrackets - closedBrackets; i++) repaired += "}";
+    return repaired;
+  }
 };
 
 // src/rag/Reranker.ts
@@ -2954,14 +2982,16 @@ var LangChainAgent = class {
     this.config = config;
   }
   /**
-   * Initializes the agent with the RAG pipeline as a primary tool.
-   * Dynamically imports LangChain dependencies to avoid build errors if missing.
+   * Initializes the LangChain ReAct agent with the RAG pipeline as a tool.
+   * Dynamically imports langchain so the package doesn't crash if it isn't installed.
    */
   async initialize(chatModel) {
     try {
-      const { DynamicTool } = await import(`${"@langchain/core/tools"}`);
-      const { ChatPromptTemplate, MessagesPlaceholder } = await import(`${"@langchain/core/prompts"}`);
-      const { AgentExecutor, createOpenAIFunctionsAgent } = await import(`${"langchain/agents"}`);
+      const [{ DynamicTool }, { HumanMessage }, { createAgent }] = await Promise.all([
+        import("@langchain/core/tools"),
+        import("@langchain/core/messages"),
+        import("langchain")
+      ]);
       const searchTool = new DynamicTool({
         name: "document_search",
         description: "Use this tool to search through the knowledge base and document repository. Input should be a specific search query.",
@@ -2970,42 +3000,53 @@ var LangChainAgent = class {
           return `Search Results:
 ${response.reply}
 
-Sources Used: ${JSON.stringify(response.sources.map((s) => s.id))}`;
+Sources Used: ${JSON.stringify(
+            response.sources.map((s) => s.id)
+          )}`;
         }
       });
-      const tools = [searchTool];
-      const prompt = ChatPromptTemplate.fromMessages([
-        ["system", this.config.llm.systemPrompt || "You are a helpful AI assistant with access to a document search tool."],
-        new MessagesPlaceholder("chat_history"),
-        ["human", "{input}"],
-        new MessagesPlaceholder("agent_scratchpad")
-      ]);
-      const agent = await createOpenAIFunctionsAgent({
-        llm: chatModel,
-        tools,
-        prompt
-      });
-      this.executor = new AgentExecutor({
-        agent,
-        tools
+      this.agent = createAgent({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        model: chatModel,
+        tools: [searchTool],
+        systemPrompt: this.config.llm.systemPrompt || "You are a helpful AI assistant with access to a document search tool."
       });
+      void HumanMessage;
     } catch (error) {
-      console.error("[LangChainAgent] Failed to initialize. Ensure 'langchain' and '@langchain/core' are installed.");
-      throw error;
+      const isMissing = error instanceof Error && error.message.includes("Cannot find module");
+      const hint = isMissing ? " Make sure 'langchain' and '@langchain/core' are installed:\n  npm install langchain @langchain/core" : "";
+      throw new Error(
+        `[LangChainAgent] Failed to initialize.${hint}
+${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
    * Run the agentic flow.
+   *
+   * LangChain v1.x: invoke takes `{ messages: [...] }` instead of `{ input, chat_history }`.
+   * The agent returns `{ messages: [...] }` — the last message is the final answer.
    */
   async run(input, chatHistory = []) {
-    if (!this.executor) {
+    var _a, _b, _c;
+    if (!this.agent) {
       throw new Error("[LangChainAgent] Agent not initialized. Call initialize() first.");
     }
-    const response = await this.executor.invoke({
-      input,
-      chat_history: chatHistory
+    const { HumanMessage, AIMessage } = await import("@langchain/core/messages");
+    const historyMessages = chatHistory.map(
+      (m) => m.role === "user" ? new HumanMessage(m.content) : new AIMessage(m.content)
+    );
+    const response = await this.agent.invoke({
+      messages: [...historyMessages, new HumanMessage(input)]
     });
-    return response.output;
+    const lastMessage = (_a = response == null ? void 0 : response.messages) == null ? void 0 : _a.at(-1);
+    if (lastMessage && typeof lastMessage.content === "string") {
+      return lastMessage.content;
+    }
+    if (Array.isArray(lastMessage == null ? void 0 : lastMessage.content)) {
+      return lastMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+    }
+    return String((_c = (_b = response == null ? void 0 : response.output) != null ? _b : response) != null ? _c : "");
   }
 };
 
@@ -3408,6 +3449,10 @@ var QueryProcessor = class {
   }
   /**
    * Constructs a QueryFilter object from extracted hints.
+   *
+   * Note: proper nouns are extracted inside `extractQueryFieldHints` and surfaced
+   * as field-less hints; `buildQueryFilter` adds them to `keywords` without
+   * re-running the proper noun regex to avoid duplication.
    */
   static buildQueryFilter(question, hints) {
     const filter = { metadata: {}, keywords: [], queryText: question };
@@ -3415,13 +3460,11 @@ var QueryProcessor = class {
       if (hint.field) {
         filter.metadata[hint.field] = hint.value;
       } else {
-        filter.keywords.push(hint.value);
+        if (!filter.keywords.includes(hint.value)) {
+          filter.keywords.push(hint.value);
+        }
       }
     }
-    for (const match of question.matchAll(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3}\b/g)) {
-      const term = this.normalizeHintValue(match[0]);
-      if (term && !filter.keywords.includes(term)) filter.keywords.push(term);
-    }
     if (Object.keys(filter.metadata || {}).length === 0) delete filter.metadata;
     if (filter.keywords && filter.keywords.length === 0) delete filter.keywords;
     return filter;
@@ -3429,10 +3472,40 @@ var QueryProcessor = class {
 };
 
 // src/core/Pipeline.ts
+var LRUEmbeddingCache = class {
+  constructor(maxSize = 500) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
 var Pipeline = class {
   constructor(config) {
     this.config = config;
-    this.embeddingCache = /* @__PURE__ */ new Map();
+    /** LRU-bounded cache: avoids re-embedding identical queries within the same process. */
+    this.embeddingCache = new LRUEmbeddingCache(500);
     this.initialised = false;
     var _a, _b, _c, _d, _e;
     this.chunker = new DocumentChunker(
@@ -3520,6 +3593,7 @@ var Pipeline = class {
   }
   /**
    * Step 2: Generate embeddings for chunks with retry logic.
+   * Uses batchEmbed when available for efficiency; falls back to sequential embedding.
    */
   async processEmbeddings(chunks) {
     const embedBatchOptions = {
@@ -3533,7 +3607,9 @@ var Pipeline = class {
       embedBatchOptions
     );
     if (vectors.length !== chunks.length) {
-      throw new Error(`Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks`);
+      throw new Error(
+        `[Pipeline] Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks. Check embedding provider logs for individual chunk failures.`
+      );
     }
     return vectors;
   }
@@ -3687,6 +3763,7 @@ ${context}`;
   }
   /**
    * Universal retrieval method combining all enabled providers.
+   * Uses an LRU-bounded embedding cache to avoid re-embedding the same query.
    */
   async retrieve(query, options) {
     var _a, _b, _c;
@@ -3719,10 +3796,13 @@ ${history.map((m) => `${m.role}: ${m.content}`).join("\n")}
 New Question: ${question}
 
 Optimized Search Query:`;
-    const rewrite = await this.llmProvider.chat([
-      { role: "system", content: "You are an assistant that optimizes search queries for RAG systems." },
-      { role: "user", content: prompt }
-    ], "");
+    const rewrite = await this.llmProvider.chat(
+      [
+        { role: "system", content: "You are an assistant that optimizes search queries for RAG systems." },
+        { role: "user", content: prompt }
+      ],
+      ""
+    );
     return rewrite.trim() || question;
   }
 };
@@ -3941,8 +4021,35 @@ var DocumentParser = class {
 };
 
 // src/handlers/index.ts
-function createChatHandler(config) {
-  const plugin = new VectorPlugin(config);
+function sseFrame(payload) {
+  return `data: ${JSON.stringify(payload)}
+
+`;
+}
+function sseTextFrame(text) {
+  return `data: ${JSON.stringify({ type: "text", text })}
+
+`;
+}
+function sseMetaFrame(meta) {
+  return `data: ${JSON.stringify(__spreadValues({ type: "metadata" }, meta != null ? meta : {}))}
+
+`;
+}
+function sseErrorFrame(message) {
+  return `data: ${JSON.stringify({ type: "error", error: message })}
+
+`;
+}
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream; charset=utf-8",
+  "Cache-Control": "no-cache, no-transform",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+  // Disable Nginx buffering for streaming
+};
+function createChatHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function POST(req) {
     try {
       const body = await req.json();
@@ -3958,67 +4065,64 @@ function createChatHandler(config) {
     }
   };
 }
-function createStreamHandler(config) {
-  const plugin = new VectorPlugin(config);
+function createStreamHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function POST(req) {
+    let body;
     try {
-      const body = await req.json();
-      const { message, history = [], namespace } = body;
-      const encoder = new TextEncoder();
-      const stream = new ReadableStream({
-        async start(controller) {
+      body = await req.json();
+    } catch (e) {
+      return new Response(JSON.stringify({ error: "Invalid JSON body" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const { message, history = [], namespace } = body;
+    if (!(message == null ? void 0 : message.trim())) {
+      return new Response(JSON.stringify({ error: "message is required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        const enqueue = (text) => controller.enqueue(encoder.encode(text));
+        try {
+          const pipelineStream = plugin.chatStream(message, history, namespace);
           try {
-            const pipelineStream = plugin.chatStream(message, history, namespace);
-            try {
-              for (var iter = __forAwait(pipelineStream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-                const chunk = temp.value;
-                if (typeof chunk === "string") {
-                  controller.enqueue(encoder.encode(chunk));
-                } else {
-                  controller.enqueue(encoder.encode(`
-
-__METADATA__${JSON.stringify(chunk)}`));
-                }
+            for (var iter = __forAwait(pipelineStream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+              const chunk = temp.value;
+              if (typeof chunk === "string") {
+                enqueue(sseTextFrame(chunk));
+              } else {
+                enqueue(sseMetaFrame(chunk));
               }
-            } catch (temp) {
-              error = [temp];
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && await temp.call(iter);
             } finally {
-              try {
-                more && (temp = iter.return) && await temp.call(iter);
-              } finally {
-                if (error)
-                  throw error[0];
-              }
+              if (error)
+                throw error[0];
             }
-            controller.close();
-          } catch (streamError) {
-            console.error("[createStreamHandler] Stream processing error:", streamError);
-            const errorMessage = streamError instanceof Error ? streamError.message : String(streamError);
-            controller.enqueue(encoder.encode(`
-
-__ERROR__${JSON.stringify({ error: errorMessage })}`));
-            controller.close();
           }
+        } catch (streamError) {
+          const errorMessage = streamError instanceof Error ? streamError.message : String(streamError);
+          console.error("[createStreamHandler] Stream error:", streamError);
+          enqueue(sseErrorFrame(errorMessage));
+        } finally {
+          controller.close();
         }
-      });
-      return new Response(stream, {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          "Connection": "keep-alive"
-        }
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Internal server error";
-      return new Response(JSON.stringify({ error: message }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
+      }
+    });
+    return new Response(stream, { headers: SSE_HEADERS });
   };
 }
-function createIngestHandler(config) {
-  const plugin = new VectorPlugin(config);
+function createIngestHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function POST(req) {
     try {
       const body = await req.json();
@@ -4034,8 +4138,8 @@ function createIngestHandler(config) {
     }
   };
 }
-function createHealthHandler(config) {
-  const plugin = new VectorPlugin(config);
+function createHealthHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function GET() {
     try {
       const health = await plugin.checkHealth();
@@ -4051,8 +4155,8 @@ function createHealthHandler(config) {
     }
   };
 }
-function createUploadHandler(config) {
-  const plugin = new VectorPlugin(config);
+function createUploadHandler(configOrPlugin) {
+  const plugin = configOrPlugin instanceof VectorPlugin ? configOrPlugin : new VectorPlugin(configOrPlugin);
   return async function POST(req) {
     try {
       const formData = await req.formData();
@@ -4090,5 +4194,9 @@ function createUploadHandler(config) {
   createHealthHandler,
   createIngestHandler,
   createStreamHandler,
-  createUploadHandler
+  createUploadHandler,
+  sseErrorFrame,
+  sseFrame,
+  sseMetaFrame,
+  sseTextFrame
 });

package/dist/handlers/index.mjs

@@ -3,8 +3,12 @@ import {
   createHealthHandler,
   createIngestHandler,
   createStreamHandler,
-  createUploadHandler
-} from "../chunk-3JR3SAWX.mjs";
+  createUploadHandler,
+  sseErrorFrame,
+  sseFrame,
+  sseMetaFrame,
+  sseTextFrame
+} from "../chunk-MWL4AGQI.mjs";
 import "../chunk-YLTMFW4M.mjs";
 import "../chunk-X4TOT24V.mjs";
 export {
@@ -12,5 +16,9 @@ export {
   createHealthHandler,
   createIngestHandler,
   createStreamHandler,
-  createUploadHandler
+  createUploadHandler,
+  sseErrorFrame,
+  sseFrame,
+  sseMetaFrame,
+  sseTextFrame
 };