@elizaos/plugin-knowledge 1.5.12 → 1.5.14

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { logger as logger10 } from "@elizaos/core";
+import { logger as logger11 } from "@elizaos/core";
 
 // src/service.ts
 import {
@@ -20,16 +20,16 @@ import {
   splitChunks
 } from "@elizaos/core";
 
-// node_modules/uuid/dist/esm/regex.js
+// node_modules/uuid/dist-node/regex.js
 var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
 
-// node_modules/uuid/dist/esm/validate.js
+// node_modules/uuid/dist-node/validate.js
 function validate(uuid) {
   return typeof uuid === "string" && regex_default.test(uuid);
 }
 var validate_default = validate;
 
-// node_modules/uuid/dist/esm/parse.js
+// node_modules/uuid/dist-node/parse.js
 function parse(uuid) {
   if (!validate_default(uuid)) {
     throw TypeError("Invalid UUID");
@@ -39,7 +39,7 @@ function parse(uuid) {
 }
 var parse_default = parse;
 
-// node_modules/uuid/dist/esm/stringify.js
+// node_modules/uuid/dist-node/stringify.js
 var byteToHex = [];
 for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -48,7 +48,7 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// node_modules/uuid/dist/esm/rng.js
+// node_modules/uuid/dist-node/rng.js
 import { randomFillSync } from "crypto";
 var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
@@ -60,7 +60,7 @@ function rng() {
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
 }
 
-// node_modules/uuid/dist/esm/v35.js
+// node_modules/uuid/dist-node/v35.js
 function stringToBytes(str) {
   str = unescape(encodeURIComponent(str));
   const bytes = new Uint8Array(str.length);
@@ -96,15 +96,12 @@ function v35(version, hash, value, namespace, buf, offset) {
   return unsafeStringify(bytes);
 }
 
-// node_modules/uuid/dist/esm/native.js
+// node_modules/uuid/dist-node/native.js
 import { randomUUID } from "crypto";
 var native_default = { randomUUID };
 
-// node_modules/uuid/dist/esm/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
+// node_modules/uuid/dist-node/v4.js
+function _v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random ?? options.rng?.() ?? rng();
   if (rnds.length < 16) {
@@ -124,9 +121,15 @@ function v4(options, buf, offset) {
   }
   return unsafeStringify(rnds);
 }
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
 var v4_default = v4;
 
-// node_modules/uuid/dist/esm/sha1.js
+// node_modules/uuid/dist-node/sha1.js
 import { createHash } from "crypto";
 function sha1(bytes) {
   if (Array.isArray(bytes)) {
@@ -138,7 +141,7 @@ function sha1(bytes) {
 }
 var sha1_default = sha1;
 
-// node_modules/uuid/dist/esm/v5.js
+// node_modules/uuid/dist-node/v5.js
 function v5(value, namespace, buf, offset) {
   return v35(80, sha1_default, value, namespace, buf, offset);
 }
@@ -1083,7 +1086,7 @@ function logCacheMetrics(result) {
 import { Buffer as Buffer2 } from "buffer";
 import * as mammoth from "mammoth";
 import { logger as logger3 } from "@elizaos/core";
-import { getDocument } from "pdfjs-dist/legacy/build/pdf.mjs";
+import { extractText } from "unpdf";
 import { createHash as createHash2 } from "crypto";
 var PLAIN_TEXT_CONTENT_TYPES = [
   "application/typescript",
@@ -1162,32 +1165,24 @@ This document was indexed for search but cannot be displayed directly in the bro
 }
 async function convertPdfToTextFromBuffer(pdfBuffer, filename) {
   const docName = filename || "unnamed-document";
-  logger3.debug(`[PdfService] Starting conversion for ${docName}`);
+  logger3.debug(`[PdfService] Starting conversion for ${docName} using unpdf`);
   try {
-    const uint8Array = new Uint8Array(pdfBuffer);
-    const pdf = await getDocument({ data: uint8Array }).promise;
-    const numPages = pdf.numPages;
-    const textPages = [];
-    for (let pageNum = 1; pageNum <= numPages; pageNum++) {
-      logger3.debug(`[PdfService] Processing page ${pageNum}/${numPages}`);
-      const page = await pdf.getPage(pageNum);
-      const textContent = await page.getTextContent();
-      const lineMap = /* @__PURE__ */ new Map();
-      textContent.items.filter(isTextItem).forEach((item) => {
-        const yPos = Math.round(item.transform[5]);
-        if (!lineMap.has(yPos)) {
-          lineMap.set(yPos, []);
-        }
-        lineMap.get(yPos).push(item);
-      });
-      const sortedLines = Array.from(lineMap.entries()).sort((a, b) => b[0] - a[0]).map(
-        ([_, items]) => items.sort((a, b) => a.transform[4] - b.transform[4]).map((item) => item.str).join(" ")
-      );
-      textPages.push(sortedLines.join("\n"));
+    const uint8Array = new Uint8Array(
+      pdfBuffer.buffer.slice(pdfBuffer.byteOffset, pdfBuffer.byteOffset + pdfBuffer.byteLength)
+    );
+    const result = await extractText(uint8Array, {
+      mergePages: true
+      // Merge all pages into a single string
+    });
+    if (!result.text || result.text.trim().length === 0) {
+      logger3.warn(`[PdfService] No text extracted from ${docName}`);
+      return "";
     }
-    const fullText = textPages.join("\n\n").replace(/\s+/g, " ").trim();
-    logger3.debug(`[PdfService] Conversion complete for ${docName}, length: ${fullText.length}`);
-    return fullText;
+    const cleanedText = result.text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\n").replace(/\n{3,}/g, "\n\n");
+    logger3.debug(
+      `[PdfService] Conversion complete for ${docName}, ${result.totalPages} pages, length: ${cleanedText.length}`
+    );
+    return cleanedText;
   } catch (error) {
     logger3.error(`[PdfService] Error converting PDF ${docName}:`, error.message);
     throw new Error(`Failed to convert PDF to text: ${error.message}`);
@@ -1336,9 +1331,6 @@ function isBinaryContentType(contentType, filename) {
   ];
   return binaryExtensions.includes(fileExt);
 }
-function isTextItem(item) {
-  return "str" in item;
-}
 function normalizeS3Url(url) {
   try {
     const urlObj = new URL(url);
@@ -3033,8 +3025,97 @@ var knowledgeProvider = {
   }
 };
 
+// src/documents-provider.ts
+import { addHeader as addHeader2, logger as logger8, MemoryType as MemoryType3 } from "@elizaos/core";
+var documentsProvider = {
+  name: "AVAILABLE_DOCUMENTS",
+  description: "List of documents available in the knowledge base. Shows which documents the agent can reference and retrieve information from.",
+  dynamic: false,
+  // Static provider - doesn't change based on the message
+  get: async (runtime) => {
+    try {
+      const knowledgeService = runtime.getService("knowledge");
+      if (!knowledgeService) {
+        logger8.warn("Knowledge service not available for documents provider");
+        return {
+          data: { documents: [] },
+          values: { documents: "" },
+          text: ""
+        };
+      }
+      const allMemories = await knowledgeService.getMemories({
+        tableName: "documents",
+        roomId: runtime.agentId,
+        count: 100
+        // Limit to 100 documents to avoid context overflow
+      });
+      const documents = allMemories.filter(
+        (memory) => memory.metadata?.type === MemoryType3.DOCUMENT
+      );
+      if (!documents || documents.length === 0) {
+        return {
+          data: { documents: [] },
+          values: { documents: "" },
+          text: ""
+        };
+      }
+      const documentsList = documents.map((doc, index) => {
+        const metadata = doc.metadata;
+        const filename = metadata?.filename || metadata?.title || `Document ${index + 1}`;
+        const fileType = metadata?.fileExt || metadata?.fileType || "unknown";
+        const source = metadata?.source || "upload";
+        const fileSize = metadata?.fileSize;
+        const parts = [filename];
+        if (fileType && fileType !== "unknown") {
+          parts.push(fileType);
+        }
+        if (fileSize) {
+          const sizeKB = Math.round(fileSize / 1024);
+          if (sizeKB > 1024) {
+            parts.push(`${Math.round(sizeKB / 1024)}MB`);
+          } else {
+            parts.push(`${sizeKB}KB`);
+          }
+        }
+        if (source && source !== "upload") {
+          parts.push(`from ${source}`);
+        }
+        return parts.join(" - ");
+      }).join("\n");
+      const documentsText = addHeader2(
+        "# Available Documents",
+        `${documents.length} document(s) in knowledge base:
+${documentsList}`
+      );
+      return {
+        data: {
+          documents: documents.map((doc) => ({
+            id: doc.id,
+            filename: doc.metadata?.filename || doc.metadata?.title,
+            fileType: doc.metadata?.fileType || doc.metadata?.fileExt,
+            source: doc.metadata?.source
+          })),
+          count: documents.length
+        },
+        values: {
+          documentsCount: documents.length,
+          documents: documentsList
+        },
+        text: documentsText
+      };
+    } catch (error) {
+      logger8.error("Error in documents provider:", error.message);
+      return {
+        data: { documents: [], error: error.message },
+        values: { documents: "" },
+        text: ""
+      };
+    }
+  }
+};
+
 // src/tests.ts
-import { MemoryType as MemoryType3, ModelType as ModelType3 } from "@elizaos/core";
+import { MemoryType as MemoryType4, ModelType as ModelType3 } from "@elizaos/core";
 import { Buffer as Buffer3 } from "buffer";
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -3159,9 +3240,9 @@ function createMockRuntime(overrides) {
       const results = Array.from(memories.values()).filter((m) => {
         if (params.roomId && m.roomId !== params.roomId) return false;
         if (params.entityId && m.entityId !== params.entityId) return false;
-        if (params.tableName === "knowledge" && m.metadata?.type !== MemoryType3.FRAGMENT)
+        if (params.tableName === "knowledge" && m.metadata?.type !== MemoryType4.FRAGMENT)
           return false;
-        if (params.tableName === "documents" && m.metadata?.type !== MemoryType3.DOCUMENT)
+        if (params.tableName === "documents" && m.metadata?.type !== MemoryType4.DOCUMENT)
           return false;
         return true;
       });
@@ -3175,7 +3256,7 @@ function createMockRuntime(overrides) {
     },
     async searchMemories(params) {
       const fragments = Array.from(memories.values()).filter(
-        (m) => m.metadata?.type === MemoryType3.FRAGMENT
+        (m) => m.metadata?.type === MemoryType4.FRAGMENT
       );
       return fragments.map((f) => ({
         ...f,
@@ -3547,7 +3628,7 @@ var KnowledgeTestSuite = class {
         if (!memory.id) {
           throw new Error("Document memory should have an ID");
         }
-        if (memory.metadata?.type !== MemoryType3.DOCUMENT) {
+        if (memory.metadata?.type !== MemoryType4.DOCUMENT) {
           throw new Error("Document memory should have DOCUMENT type");
         }
         if (memory.content.text !== params.text) {
@@ -3920,7 +4001,7 @@ var KnowledgeTestSuite = class {
 var tests_default = new KnowledgeTestSuite();
 
 // src/actions.ts
-import { logger as logger8, stringToUuid } from "@elizaos/core";
+import { logger as logger9, stringToUuid } from "@elizaos/core";
 import * as fs3 from "fs";
 import * as path3 from "path";
 var processKnowledgeAction = {
@@ -3978,7 +4059,7 @@ var processKnowledgeAction = {
     const hasPath = pathPattern.test(text);
     const service = runtime.getService(KnowledgeService.serviceType);
     if (!service) {
-      logger8.warn("Knowledge service not available for PROCESS_KNOWLEDGE action");
+      logger9.warn("Knowledge service not available for PROCESS_KNOWLEDGE action");
       return false;
     }
     return hasKeyword || hasPath;
@@ -4056,7 +4137,7 @@ var processKnowledgeAction = {
         await callback(response);
       }
     } catch (error) {
-      logger8.error({ error }, "Error in PROCESS_KNOWLEDGE action");
+      logger9.error({ error }, "Error in PROCESS_KNOWLEDGE action");
       const errorResponse = {
         text: `I encountered an error while processing the knowledge: ${error instanceof Error ? error.message : "Unknown error"}`
       };
@@ -4147,7 +4228,7 @@ ${formattedResults}`
         await callback(response);
       }
     } catch (error) {
-      logger8.error({ error }, "Error in SEARCH_KNOWLEDGE action");
+      logger9.error({ error }, "Error in SEARCH_KNOWLEDGE action");
       const errorResponse = {
         text: `I encountered an error while searching the knowledge base: ${error instanceof Error ? error.message : "Unknown error"}`
       };
@@ -4160,7 +4241,7 @@ ${formattedResults}`
 var knowledgeActions = [processKnowledgeAction, searchKnowledgeAction];
 
 // src/routes.ts
-import { MemoryType as MemoryType4, createUniqueUuid as createUniqueUuid2, logger as logger9, ModelType as ModelType4 } from "@elizaos/core";
+import { MemoryType as MemoryType5, createUniqueUuid as createUniqueUuid2, logger as logger10, ModelType as ModelType4 } from "@elizaos/core";
 import fs4 from "fs";
 import path4 from "path";
 import multer from "multer";
@@ -4211,7 +4292,7 @@ var cleanupFile = (filePath) => {
     try {
       fs4.unlinkSync(filePath);
     } catch (error) {
-      logger9.error({ error }, `Error cleaning up file ${filePath}`);
+      logger10.error({ error }, `Error cleaning up file ${filePath}`);
     }
   }
 };
@@ -4238,15 +4319,15 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const invalidFiles = files.filter((file) => {
         if (file.size === 0) {
-          logger9.warn(`File ${file.originalname} is empty`);
+          logger10.warn(`File ${file.originalname} is empty`);
           return true;
         }
         if (!file.originalname || file.originalname.trim() === "") {
-          logger9.warn(`File has no name`);
+          logger10.warn(`File has no name`);
           return true;
         }
         if (!file.path) {
-          logger9.warn(`File ${file.originalname} has no path`);
+          logger10.warn(`File ${file.originalname} has no path`);
           return true;
         }
         return false;
@@ -4263,7 +4344,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const agentId = req.body.agentId || req.query.agentId;
       if (!agentId) {
-        logger9.error("[Document Processor] \u274C No agent ID provided in upload request");
+        logger10.error("[Document Processor] \u274C No agent ID provided in upload request");
         return sendError(
           res,
           400,
@@ -4272,11 +4353,11 @@ async function uploadKnowledgeHandler(req, res, runtime) {
         );
       }
       const worldId = req.body.worldId || agentId;
-      logger9.info(`[Document Processor] \u{1F4E4} Processing file upload for agent: ${agentId}`);
+      logger10.info(`[Document Processor] \u{1F4E4} Processing file upload for agent: ${agentId}`);
       const processingPromises = files.map(async (file, index) => {
         const originalFilename = file.originalname;
         const filePath = file.path;
-        logger9.debug(
+        logger10.debug(
           `[Document Processor] \u{1F4C4} Processing file: ${originalFilename} (agent: ${agentId})`
         );
         try {
@@ -4311,7 +4392,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             status: "success"
           };
         } catch (fileError) {
-          logger9.error(
+          logger10.error(
             `[Document Processor] \u274C Error processing file ${file.originalname}:`,
             fileError
           );
@@ -4334,7 +4415,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const agentId = req.body.agentId || req.query.agentId;
       if (!agentId) {
-        logger9.error("[Document Processor] \u274C No agent ID provided in URL request");
+        logger10.error("[Document Processor] \u274C No agent ID provided in URL request");
         return sendError(
           res,
           400,
@@ -4342,7 +4423,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           "Agent ID is required for uploading knowledge from URLs"
         );
       }
-      logger9.info(`[Document Processor] \u{1F4E4} Processing URL upload for agent: ${agentId}`);
+      logger10.info(`[Document Processor] \u{1F4E4} Processing URL upload for agent: ${agentId}`);
       const processingPromises = fileUrls.map(async (fileUrl) => {
         try {
           const normalizedUrl = normalizeS3Url(fileUrl);
@@ -4350,7 +4431,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           const pathSegments = urlObject.pathname.split("/");
           const encodedFilename = pathSegments[pathSegments.length - 1] || "document.pdf";
           const originalFilename = decodeURIComponent(encodedFilename);
-          logger9.debug(`[Document Processor] \u{1F310} Fetching content from URL: ${fileUrl}`);
+          logger10.debug(`[Document Processor] \u{1F310} Fetching content from URL: ${fileUrl}`);
           const { content, contentType: fetchedContentType } = await fetchUrlContent(fileUrl);
           let contentType = fetchedContentType;
           if (contentType === "application/octet-stream") {
@@ -4390,7 +4471,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
               url: normalizedUrl
             }
           };
-          logger9.debug(
+          logger10.debug(
             `[Document Processor] \u{1F4C4} Processing knowledge from URL: ${originalFilename} (type: ${contentType})`
           );
           const result = await service.addKnowledge(addKnowledgeOpts);
@@ -4405,7 +4486,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             status: "success"
           };
         } catch (urlError) {
-          logger9.error(`[Document Processor] \u274C Error processing URL ${fileUrl}:`, urlError);
+          logger10.error(`[Document Processor] \u274C Error processing URL ${fileUrl}:`, urlError);
           return {
             fileUrl,
             status: "error_processing",
@@ -4417,7 +4498,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       sendSuccess(res, results);
     }
   } catch (error) {
-    logger9.error({ error }, "[Document Processor] \u274C Error processing knowledge");
+    logger10.error({ error }, "[Document Processor] \u274C Error processing knowledge");
     if (hasUploadedFiles) {
       cleanupFiles(req.files);
     }
@@ -4456,7 +4537,7 @@ async function getKnowledgeDocumentsHandler(req, res, runtime) {
         // Or if the URL is stored in the metadata (check if it exists)
         memory.metadata && "url" in memory.metadata && typeof memory.metadata.url === "string" && normalizedRequestUrls.includes(normalizeS3Url(memory.metadata.url))
       );
-      logger9.debug(
+      logger10.debug(
         `[Document Processor] \u{1F50D} Filtered documents by URLs: ${fileUrls.length} URLs, found ${filteredMemories.length} matching documents`
       );
     }
@@ -4471,12 +4552,12 @@ async function getKnowledgeDocumentsHandler(req, res, runtime) {
       totalRequested: fileUrls ? fileUrls.length : 0
     });
   } catch (error) {
-    logger9.error({ error }, "[Document Processor] \u274C Error retrieving documents");
+    logger10.error({ error }, "[Document Processor] \u274C Error retrieving documents");
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve documents", error.message);
   }
 }
 async function deleteKnowledgeDocumentHandler(req, res, runtime) {
-  logger9.debug(`[Document Processor] \u{1F5D1}\uFE0F DELETE request for document: ${req.params.knowledgeId}`);
+  logger10.debug(`[Document Processor] \u{1F5D1}\uFE0F DELETE request for document: ${req.params.knowledgeId}`);
   const service = runtime.getService(KnowledgeService.serviceType);
   if (!service) {
     return sendError(
@@ -4488,22 +4569,22 @@ async function deleteKnowledgeDocumentHandler(req, res, runtime) {
   }
   const knowledgeId = req.params.knowledgeId;
   if (!knowledgeId || knowledgeId.length < 36) {
-    logger9.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
+    logger10.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
     return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
   }
   try {
     const typedKnowledgeId = knowledgeId;
-    logger9.debug(`[Document Processor] \u{1F5D1}\uFE0F Deleting document: ${typedKnowledgeId}`);
+    logger10.debug(`[Document Processor] \u{1F5D1}\uFE0F Deleting document: ${typedKnowledgeId}`);
     await service.deleteMemory(typedKnowledgeId);
-    logger9.info(`[Document Processor] \u2705 Successfully deleted document: ${typedKnowledgeId}`);
+    logger10.info(`[Document Processor] \u2705 Successfully deleted document: ${typedKnowledgeId}`);
     sendSuccess(res, null, 204);
   } catch (error) {
-    logger9.error({ error }, `[Document Processor] \u274C Error deleting document ${knowledgeId}`);
+    logger10.error({ error }, `[Document Processor] \u274C Error deleting document ${knowledgeId}`);
     sendError(res, 500, "DELETE_ERROR", "Failed to delete document", error.message);
   }
 }
 async function getKnowledgeByIdHandler(req, res, runtime) {
-  logger9.debug(`[Document Processor] \u{1F50D} GET request for document: ${req.params.knowledgeId}`);
+  logger10.debug(`[Document Processor] \u{1F50D} GET request for document: ${req.params.knowledgeId}`);
   const service = runtime.getService(KnowledgeService.serviceType);
   if (!service) {
     return sendError(
@@ -4515,11 +4596,11 @@ async function getKnowledgeByIdHandler(req, res, runtime) {
   }
   const knowledgeId = req.params.knowledgeId;
   if (!knowledgeId || knowledgeId.length < 36) {
-    logger9.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
+    logger10.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
     return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
   }
   try {
-    logger9.debug(`[Document Processor] \u{1F50D} Retrieving document: ${knowledgeId}`);
+    logger10.debug(`[Document Processor] \u{1F50D} Retrieving document: ${knowledgeId}`);
     const agentId = req.query.agentId;
     const memories = await service.getMemories({
       tableName: "documents",
@@ -4536,20 +4617,20 @@ async function getKnowledgeByIdHandler(req, res, runtime) {
     };
     sendSuccess(res, { document: cleanDocument });
   } catch (error) {
-    logger9.error({ error }, `[Document Processor] \u274C Error retrieving document ${knowledgeId}`);
+    logger10.error({ error }, `[Document Processor] \u274C Error retrieving document ${knowledgeId}`);
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve document", error.message);
   }
 }
 async function knowledgePanelHandler(req, res, runtime) {
   const agentId = runtime.agentId;
-  logger9.debug(`[Document Processor] \u{1F310} Serving knowledge panel for agent ${agentId}`);
+  logger10.debug(`[Document Processor] \u{1F310} Serving knowledge panel for agent ${agentId}`);
   const requestPath = req.originalUrl || req.url || req.path;
   const pluginBasePath = requestPath.replace(/\/display.*$/, "");
-  logger9.debug(`[Document Processor] \u{1F310} Plugin base path: ${pluginBasePath}`);
+  logger10.debug(`[Document Processor] \u{1F310} Plugin base path: ${pluginBasePath}`);
   try {
     const currentDir = path4.dirname(new URL(import.meta.url).pathname);
     const frontendPath = path4.join(currentDir, "../dist/index.html");
-    logger9.debug(`[Document Processor] \u{1F310} Looking for frontend at: ${frontendPath}`);
+    logger10.debug(`[Document Processor] \u{1F310} Looking for frontend at: ${frontendPath}`);
     if (fs4.existsSync(frontendPath)) {
       const html = await fs4.promises.readFile(frontendPath, "utf8");
       let injectedHtml = html.replace(
@@ -4585,10 +4666,10 @@ async function knowledgePanelHandler(req, res, runtime) {
             }
           }
         } catch (manifestError) {
-          logger9.error({ error: manifestError }, "[Document Processor] \u274C Error reading manifest");
+          logger10.error({ error: manifestError }, "[Document Processor] \u274C Error reading manifest");
         }
       }
-      logger9.debug(`[Document Processor] \u{1F310} Using fallback with CSS: ${cssFile}, JS: ${jsFile}`);
+      logger10.debug(`[Document Processor] \u{1F310} Using fallback with CSS: ${cssFile}, JS: ${jsFile}`);
       const html = `
 <!DOCTYPE html>
 <html lang="en">
@@ -4622,14 +4703,14 @@ async function knowledgePanelHandler(req, res, runtime) {
       res.end(html);
     }
   } catch (error) {
-    logger9.error({ error }, "[Document Processor] \u274C Error serving frontend");
+    logger10.error({ error }, "[Document Processor] \u274C Error serving frontend");
     sendError(res, 500, "FRONTEND_ERROR", "Failed to load knowledge panel", error.message);
   }
 }
 async function frontendAssetHandler(req, res, runtime) {
   try {
     const fullPath = req.originalUrl || req.url || req.path;
-    logger9.debug(`[Document Processor] \u{1F310} Asset request: ${fullPath}`);
+    logger10.debug(`[Document Processor] \u{1F310} Asset request: ${fullPath}`);
     const currentDir = path4.dirname(new URL(import.meta.url).pathname);
     const assetsMarker = "/assets/";
     const assetsStartIndex = fullPath.lastIndexOf(assetsMarker);
@@ -4650,7 +4731,7 @@ async function frontendAssetHandler(req, res, runtime) {
       );
     }
     const assetPath = path4.join(currentDir, "../dist/assets", assetName);
-    logger9.debug(`[Document Processor] \u{1F310} Serving asset: ${assetPath}`);
+    logger10.debug(`[Document Processor] \u{1F310} Serving asset: ${assetPath}`);
     if (fs4.existsSync(assetPath)) {
       const fileStream = fs4.createReadStream(assetPath);
       let contentType = "application/octet-stream";
@@ -4665,7 +4746,7 @@ async function frontendAssetHandler(req, res, runtime) {
       sendError(res, 404, "NOT_FOUND", `Asset not found: ${req.url}`);
     }
   } catch (error) {
-    logger9.error({ error }, `[Document Processor] \u274C Error serving asset ${req.url}`);
+    logger10.error({ error }, `[Document Processor] \u274C Error serving asset ${req.url}`);
     sendError(res, 500, "ASSET_ERROR", `Failed to load asset ${req.url}`, error.message);
   }
 }
@@ -4726,7 +4807,7 @@ async function getKnowledgeChunksHandler(req, res, runtime) {
       }
     });
   } catch (error) {
-    logger9.error({ error }, "[Document Processor] \u274C Error retrieving chunks");
+    logger10.error({ error }, "[Document Processor] \u274C Error retrieving chunks");
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve knowledge chunks", error.message);
   }
 }
@@ -4748,14 +4829,14 @@ async function searchKnowledgeHandler(req, res, runtime) {
       return sendError(res, 400, "INVALID_QUERY", "Search query cannot be empty");
     }
     if (req.query.threshold && (parsedThreshold < 0 || parsedThreshold > 1)) {
-      logger9.debug(
+      logger10.debug(
         `[Document Processor] \u{1F50D} Threshold value ${parsedThreshold} was clamped to ${matchThreshold}`
       );
     }
     if (req.query.limit && (parsedLimit < 1 || parsedLimit > 100)) {
-      logger9.debug(`[Document Processor] \u{1F50D} Limit value ${parsedLimit} was clamped to ${limit}`);
+      logger10.debug(`[Document Processor] \u{1F50D} Limit value ${parsedLimit} was clamped to ${limit}`);
     }
-    logger9.debug(
+    logger10.debug(
       `[Document Processor] \u{1F50D} Searching: "${searchText}" (threshold: ${matchThreshold}, limit: ${limit})`
     );
     const embedding = await runtime.useModel(ModelType4.TEXT_EMBEDDING, {
@@ -4782,7 +4863,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
               documentFilename = document.metadata.filename || documentFilename;
             }
           } catch (e) {
-            logger9.debug(`Could not fetch document ${documentId} for fragment`);
+            logger10.debug(`Could not fetch document ${documentId} for fragment`);
           }
         }
         return {
@@ -4797,7 +4878,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
         };
       })
     );
-    logger9.info(
+    logger10.info(
       `[Document Processor] \u{1F50D} Found ${enhancedResults.length} results for: "${searchText}"`
     );
     sendSuccess(res, {
@@ -4807,7 +4888,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
       count: enhancedResults.length
     });
   } catch (error) {
-    logger9.error({ error }, "[Document Processor] \u274C Error searching knowledge");
+    logger10.error({ error }, "[Document Processor] \u274C Error searching knowledge");
     sendError(res, 500, "SEARCH_ERROR", "Failed to search knowledge", error.message);
   }
 }
@@ -4824,7 +4905,7 @@ async function getGraphNodesHandler(req, res, runtime) {
     const page = Number.isNaN(parsedPage) || parsedPage < 1 ? 1 : parsedPage;
     const limit = Number.isNaN(parsedLimit) || parsedLimit < 1 ? 20 : Math.min(parsedLimit, 50);
     const offset = (page - 1) * limit;
-    logger9.debug(
+    logger10.debug(
       `[Graph API] \u{1F4CA} Fetching graph nodes: page=${page}, limit=${limit}, type=${type || "all"}, agent=${agentId}`
     );
     const totalDocuments = await service.countMemories({
@@ -4845,7 +4926,7 @@ async function getGraphNodesHandler(req, res, runtime) {
     const links = [];
     paginatedDocuments.forEach((doc) => {
       if (!doc.id) {
-        logger9.warn(`[Graph API] \u26A0\uFE0F  Skipping document without ID`);
+        logger10.warn(`[Graph API] \u26A0\uFE0F  Skipping document without ID`);
         return;
       }
       nodes.push({ id: doc.id, type: "document" });
@@ -4857,9 +4938,9 @@ async function getGraphNodesHandler(req, res, runtime) {
         count: 5e4
         // Reduced from 100000 - still high enough for large documents
       });
-      logger9.debug(`[Graph API] \u{1F4CA} Total fragments found: ${allFragments.length}`);
+      logger10.debug(`[Graph API] \u{1F4CA} Total fragments found: ${allFragments.length}`);
       if (allFragments.length > 0) {
-        logger9.debug(
+        logger10.debug(
           `[Graph API] \u{1F4CA} Sample fragment metadata: ${JSON.stringify(
             allFragments.slice(0, 3).map((f) => ({
               id: f.id,
@@ -4875,17 +4956,17 @@ async function getGraphNodesHandler(req, res, runtime) {
         const docFragments = allFragments.filter((fragment) => {
           const metadata = fragment.metadata;
           const typeString = typeof metadata?.type === "string" ? metadata.type : null;
-          const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === MemoryType4.FRAGMENT || // If no type but has documentId, assume it's a fragment
+          const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === MemoryType5.FRAGMENT || // If no type but has documentId, assume it's a fragment
           !metadata?.type && metadata?.documentId;
           return metadata?.documentId === doc.id && isFragment;
         });
         if (docFragments.length > 0) {
-          logger9.debug(`[Graph API] \u{1F4CA} Document ${doc.id} has ${docFragments.length} fragments`);
+          logger10.debug(`[Graph API] \u{1F4CA} Document ${doc.id} has ${docFragments.length} fragments`);
         }
         docFragments.forEach((frag) => {
           const docId = doc.id;
           if (!frag.id || !docId) {
-            logger9.warn(
+            logger10.warn(
               `[Graph API] \u26A0\uFE0F  Skipping fragment without ID for document ${docId || "unknown"}`
             );
             return;
@@ -4894,7 +4975,7 @@ async function getGraphNodesHandler(req, res, runtime) {
           links.push({ source: docId, target: frag.id });
         });
       });
-      logger9.info(
+      logger10.info(
         `[Graph API] \u{1F4CA} Final graph: ${nodes.length} nodes (${paginatedDocuments.length} documents), ${links.length} links`
       );
     }
@@ -4909,7 +4990,7 @@ async function getGraphNodesHandler(req, res, runtime) {
       }
     });
   } catch (error) {
-    logger9.error("[Graph API] \u274C Error fetching graph nodes:", error);
+    logger10.error("[Graph API] \u274C Error fetching graph nodes:", error);
     sendError(res, 500, "GRAPH_ERROR", "Failed to fetch graph nodes", error.message);
   }
 }
@@ -4924,24 +5005,24 @@ async function getGraphNodeDetailsHandler(req, res, runtime) {
     return sendError(res, 400, "INVALID_ID", "Invalid node ID format");
   }
   try {
-    logger9.info(`[Graph API] \u{1F4CA} Fetching node details for: ${nodeId}, agent: ${agentId}`);
+    logger10.info(`[Graph API] \u{1F4CA} Fetching node details for: ${nodeId}, agent: ${agentId}`);
     const allDocuments = await service.getMemories({
       tableName: "documents",
       count: 1e4
     });
-    logger9.debug(`[Graph API] \u{1F4CA} Total documents in DB: ${allDocuments.length}`);
+    logger10.debug(`[Graph API] \u{1F4CA} Total documents in DB: ${allDocuments.length}`);
     let document = allDocuments.find((doc) => doc.id === nodeId && doc.roomId === agentId);
     if (!document) {
-      logger9.debug(`[Graph API] \u{1F4CA} Document not found with roomId filter, trying without filter`);
+      logger10.debug(`[Graph API] \u{1F4CA} Document not found with roomId filter, trying without filter`);
       document = allDocuments.find((doc) => doc.id === nodeId);
       if (document) {
-        logger9.warn(
+        logger10.warn(
           `[Graph API] \u26A0\uFE0F Document ${nodeId} found but has different roomId: ${document.roomId} vs ${agentId}`
         );
       }
     }
     if (document) {
-      logger9.info(`[Graph API] \u2705 Found document: ${nodeId}`);
+      logger10.info(`[Graph API] \u2705 Found document: ${nodeId}`);
       sendSuccess(res, {
         id: document.id,
         type: "document",
@@ -4955,25 +5036,25 @@ async function getGraphNodeDetailsHandler(req, res, runtime) {
       });
       return;
     }
-    logger9.debug(`[Graph API] \u{1F4CA} Document not found, searching in fragments`);
+    logger10.debug(`[Graph API] \u{1F4CA} Document not found, searching in fragments`);
     const allFragments = await service.getMemories({
       tableName: "knowledge",
       count: 5e4
       // Reduced from 100000 - still high enough for large documents
     });
-    logger9.debug(`[Graph API] \u{1F4CA} Total fragments in DB: ${allFragments.length}`);
+    logger10.debug(`[Graph API] \u{1F4CA} Total fragments in DB: ${allFragments.length}`);
     let fragment = allFragments.find((frag) => frag.id === nodeId && frag.roomId === agentId);
     if (!fragment) {
-      logger9.debug(`[Graph API] \u{1F4CA} Fragment not found with roomId filter, trying without filter`);
+      logger10.debug(`[Graph API] \u{1F4CA} Fragment not found with roomId filter, trying without filter`);
       fragment = allFragments.find((frag) => frag.id === nodeId);
       if (fragment) {
-        logger9.warn(
+        logger10.warn(
           `[Graph API] \u26A0\uFE0F Fragment ${nodeId} found but has different roomId: ${fragment.roomId} vs ${agentId}`
         );
       }
     }
     if (fragment) {
-      logger9.info(`[Graph API] \u2705 Found fragment: ${nodeId}`);
+      logger10.info(`[Graph API] \u2705 Found fragment: ${nodeId}`);
       sendSuccess(res, {
         id: fragment.id,
         type: "fragment",
@@ -4987,10 +5068,10 @@ async function getGraphNodeDetailsHandler(req, res, runtime) {
       });
       return;
     }
-    logger9.error(`[Graph API] \u274C Node ${nodeId} not found in documents or fragments`);
+    logger10.error(`[Graph API] \u274C Node ${nodeId} not found in documents or fragments`);
     sendError(res, 404, "NOT_FOUND", `Node with ID ${nodeId} not found`);
   } catch (error) {
-    logger9.error(`[Graph API] \u274C Error fetching node details for ${nodeId}:`, error);
+    logger10.error(`[Graph API] \u274C Error fetching node details for ${nodeId}:`, error);
     sendError(res, 500, "GRAPH_ERROR", "Failed to fetch node details", error.message);
   }
 }
@@ -5005,7 +5086,7 @@ async function expandDocumentGraphHandler(req, res, runtime) {
     return sendError(res, 400, "INVALID_ID", "Invalid document ID format");
   }
   try {
-    logger9.debug(`[Graph API] \u{1F4CA} Expanding document: ${documentId}, agent: ${agentId}`);
+    logger10.debug(`[Graph API] \u{1F4CA} Expanding document: ${documentId}, agent: ${agentId}`);
     const allFragments = await service.getMemories({
       tableName: "knowledge",
       roomId: agentId,
@@ -5013,33 +5094,33 @@ async function expandDocumentGraphHandler(req, res, runtime) {
       count: 5e4
       // Reduced from 100000 - still high enough for large documents
     });
-    logger9.debug(`[Graph API] \u{1F4CA} Total fragments in knowledge table: ${allFragments.length}`);
+    logger10.debug(`[Graph API] \u{1F4CA} Total fragments in knowledge table: ${allFragments.length}`);
     if (allFragments.length > 0 && process.env.NODE_ENV !== "production") {
-      logger9.debug(
+      logger10.debug(
         `[Graph API] \u{1F4CA} Sample fragment metadata: ${JSON.stringify(allFragments[0].metadata)}`
       );
       const uniqueTypes = new Set(allFragments.map((f) => f.metadata?.type));
-      logger9.debug(
+      logger10.debug(
         `[Graph API] \u{1F4CA} Unique metadata types found in knowledge table: ${JSON.stringify(Array.from(uniqueTypes))}`
       );
       const relevantFragments = allFragments.filter((fragment) => {
         const metadata = fragment.metadata;
         const hasDocumentId = metadata?.documentId === documentId;
         if (hasDocumentId) {
-          logger9.debug(
+          logger10.debug(
             `[Graph API] \u{1F4CA} Fragment ${fragment.id} metadata: ${JSON.stringify(metadata)}`
           );
         }
         return hasDocumentId;
       });
-      logger9.debug(
+      logger10.debug(
         `[Graph API] \u{1F4CA} Fragments with matching documentId: ${relevantFragments.length}`
       );
     }
     const documentFragments = allFragments.filter((fragment) => {
       const metadata = fragment.metadata;
       const typeString = typeof metadata?.type === "string" ? metadata.type : null;
-      const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === MemoryType4.FRAGMENT || // If no type but has documentId, assume it's a fragment
+      const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === MemoryType5.FRAGMENT || // If no type but has documentId, assume it's a fragment
       !metadata?.type && metadata?.documentId;
       return metadata?.documentId === documentId && isFragment;
     });
@@ -5051,7 +5132,7 @@ async function expandDocumentGraphHandler(req, res, runtime) {
       source: documentId,
       target: frag.id
     }));
-    logger9.info(`[Graph API] \u{1F4CA} Found ${nodes.length} fragments for document ${documentId}`);
+    logger10.info(`[Graph API] \u{1F4CA} Found ${nodes.length} fragments for document ${documentId}`);
     sendSuccess(res, {
       documentId,
       nodes,
@@ -5059,7 +5140,7 @@ async function expandDocumentGraphHandler(req, res, runtime) {
       fragmentCount: nodes.length
     });
   } catch (error) {
-    logger9.error(`[Graph API] \u274C Error expanding document ${documentId}:`, error);
+    logger10.error(`[Graph API] \u274C Error expanding document ${documentId}:`, error);
     sendError(res, 500, "GRAPH_ERROR", "Failed to expand document", error.message);
   }
 }
@@ -5071,7 +5152,7 @@ async function uploadKnowledgeWithMulter(req, res, runtime) {
   );
   uploadArray(req, res, (err) => {
     if (err) {
-      logger9.error({ error: err }, "[Document Processor] \u274C File upload error");
+      logger10.error({ error: err }, "[Document Processor] \u274C File upload error");
       return sendError(res, 400, "UPLOAD_ERROR", err.message);
     }
     uploadKnowledgeHandler(req, res, runtime);
@@ -5145,13 +5226,13 @@ function createKnowledgePlugin(config = {}) {
     name: "knowledge",
     description: "Plugin for Retrieval Augmented Generation, including knowledge management and embedding.",
     services: [KnowledgeService],
-    providers: [knowledgeProvider]
+    providers: [knowledgeProvider, documentsProvider]
   };
   if (enableUI || enableRoutes) {
     plugin.routes = knowledgeRoutes;
-    logger10.debug("[Knowledge Plugin] Routes enabled");
+    logger11.debug("[Knowledge Plugin] Routes enabled");
   } else {
-    logger10.info("[Knowledge Plugin] Running in headless mode (no routes or UI)");
+    logger11.info("[Knowledge Plugin] Running in headless mode (no routes or UI)");
   }
   if (enableActions) {
     plugin.actions = knowledgeActions;
@@ -5186,6 +5267,7 @@ export {
   ModelConfigSchema,
   createKnowledgePlugin,
   index_default as default,
+  documentsProvider,
   knowledgePlugin,
   knowledgePluginCore,
   knowledgePluginHeadless,