@elizaos/plugin-knowledge 1.0.7 → 1.0.9

package/dist/index.js

@@ -2,11 +2,13 @@ import {
   convertPdfToTextFromBuffer,
   extractTextFromFileBuffer,
   fetchUrlContent,
+  generateContentBasedId,
   isBinaryContentType,
   loadDocsFromPath,
   looksLikeBase64,
-  normalizeS3Url
-} from "./chunk-536BD2UA.js";
+  normalizeS3Url,
+  v4_default
+} from "./chunk-QH7GBNKB.js";
 
 // src/index.ts
 import { logger as logger7 } from "@elizaos/core";
@@ -206,51 +208,6 @@ import {
   splitChunks
 } from "@elizaos/core";
 
-// node_modules/uuid/dist/esm/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-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
-import { randomFillSync } from "crypto";
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// node_modules/uuid/dist/esm/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();
-  }
-  options = options || {};
-  const rnds = options.random || (options.rng || rng)();
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
 // src/ctx-embeddings.ts
 var DEFAULT_CHUNK_TOKEN_SIZE = 500;
 var DEFAULT_CHUNK_OVERLAP_TOKENS = 100;
@@ -674,14 +631,6 @@ function getChunkWithContext(chunkContent, generatedContext) {
     );
     return chunkContent;
   }
-  if (!generatedContext.includes(chunkContent)) {
-    console.warn(
-      "Generated context does not contain the original chunk. Appending original to ensure data integrity."
-    );
-    return `${generatedContext.trim()}
-
-${chunkContent}`;
-  }
   return generatedContext.trim();
 }
 
@@ -1015,7 +964,9 @@ var useCustomLLM = shouldUseCustomLLM();
 if (ctxKnowledgeEnabled) {
   logger3.info(`Document processor starting with Contextual Knowledge ENABLED`);
   if (useCustomLLM) {
-    logger3.info(`Using Custom LLM with provider: ${process.env.TEXT_PROVIDER}, model: ${process.env.TEXT_MODEL}`);
+    logger3.info(
+      `Using Custom LLM with provider: ${process.env.TEXT_PROVIDER}, model: ${process.env.TEXT_MODEL}`
+    );
   } else {
     logger3.info(`Using ElizaOS Runtime LLM (default behavior)`);
   }
@@ -1307,6 +1258,8 @@ async function getContextualizedChunks(runtime, fullDocumentText, chunks, conten
   }
 }
 async function generateContextsInBatch(runtime, fullDocumentText, chunks, contentType, batchIndices) {
+  console.log("####### generateContextsInBatch FULLL DOCUMENT", fullDocumentText);
+  console.log("####### generateContextsInBatch CHUNKS", chunks);
   if (!chunks || chunks.length === 0) {
     return [];
   }
@@ -1315,6 +1268,9 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
   const config = validateModelConfig();
   const isUsingOpenRouter = config.TEXT_PROVIDER === "openrouter";
   const isUsingCacheCapableModel = isUsingOpenRouter && (config.TEXT_MODEL?.toLowerCase().includes("claude") || config.TEXT_MODEL?.toLowerCase().includes("gemini"));
+  logger3.info(
+    `Using provider: ${config.TEXT_PROVIDER}, model: ${config.TEXT_MODEL}, caching capability: ${isUsingCacheCapableModel}`
+  );
   const promptConfigs = prepareContextPrompts(
     chunks,
     fullDocumentText,
@@ -1337,15 +1293,11 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
         const generateTextOperation = async () => {
           if (useCustomLLM) {
             if (item.usesCaching) {
-              return await generateText(
-                item.promptText,
-                item.systemPrompt,
-                {
-                  cacheDocument: item.fullDocumentTextForContext,
-                  cacheOptions: { type: "ephemeral" },
-                  autoCacheContextualRetrieval: true
-                }
-              );
+              return await generateText(item.promptText, item.systemPrompt, {
+                cacheDocument: item.fullDocumentTextForContext,
+                cacheOptions: { type: "ephemeral" },
+                autoCacheContextualRetrieval: true
+              });
             } else {
               return await generateText(item.prompt);
             }
@@ -1366,7 +1318,7 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
           generateTextOperation,
           `context generation for chunk ${item.originalIndex}`
         );
-        const generatedContext = llmResponse.text;
+        const generatedContext = typeof llmResponse === "string" ? llmResponse : llmResponse.text;
         const contextualizedText = getChunkWithContext(item.chunkText, generatedContext);
         logger3.debug(
           `Context added for chunk ${item.originalIndex}. New length: ${contextualizedText.length}`
@@ -1630,36 +1582,42 @@ var KnowledgeService = class _KnowledgeService extends Service {
    */
   async addKnowledge(options) {
     const agentId = options.agentId || this.runtime.agentId;
+    const contentBasedId = generateContentBasedId(options.content, agentId, {
+      includeFilename: options.originalFilename,
+      contentType: options.contentType,
+      maxChars: 2e3
+      // Use first 2KB of content for ID generation
+    });
     logger4.info(
-      `KnowledgeService processing document for agent: ${agentId}, file: ${options.originalFilename}, type: ${options.contentType}`
+      `KnowledgeService processing document for agent: ${agentId}, file: ${options.originalFilename}, type: ${options.contentType}, generated ID: ${contentBasedId}`
     );
     try {
-      const existingDocument = await this.runtime.getMemoryById(options.clientDocumentId);
+      const existingDocument = await this.runtime.getMemoryById(contentBasedId);
       if (existingDocument && existingDocument.metadata?.type === MemoryType2.DOCUMENT) {
         logger4.info(
-          `Document ${options.originalFilename} with ID ${options.clientDocumentId} already exists. Skipping processing.`
+          `Document ${options.originalFilename} with ID ${contentBasedId} already exists. Skipping processing.`
         );
         const fragments = await this.runtime.getMemories({
           tableName: "knowledge"
-          // Assuming fragments store original documentId in metadata.documentId
-          // This query might need adjustment based on actual fragment metadata structure.
-          // A more robust way would be to query where metadata.documentId === options.clientDocumentId
         });
         const relatedFragments = fragments.filter(
-          (f) => f.metadata?.type === MemoryType2.FRAGMENT && f.metadata.documentId === options.clientDocumentId
+          (f) => f.metadata?.type === MemoryType2.FRAGMENT && f.metadata.documentId === contentBasedId
         );
         return {
-          clientDocumentId: options.clientDocumentId,
+          clientDocumentId: contentBasedId,
           storedDocumentMemoryId: existingDocument.id,
           fragmentCount: relatedFragments.length
         };
       }
     } catch (error) {
       logger4.debug(
-        `Document ${options.clientDocumentId} not found or error checking existence, proceeding with processing: ${error instanceof Error ? error.message : String(error)}`
+        `Document ${contentBasedId} not found or error checking existence, proceeding with processing: ${error instanceof Error ? error.message : String(error)}`
       );
     }
-    return this.processDocument(options);
+    return this.processDocument({
+      ...options,
+      clientDocumentId: contentBasedId
+    });
   }
   /**
    * Process a document regardless of type - Called by public addKnowledge
@@ -1851,7 +1809,12 @@ var KnowledgeService = class _KnowledgeService extends Service {
     const processingPromises = items.map(async (item) => {
       await this.knowledgeProcessingSemaphore.acquire();
       try {
-        const knowledgeId = createUniqueUuid(this.runtime.agentId + item, item);
+        const knowledgeId = generateContentBasedId(item, this.runtime.agentId, {
+          maxChars: 2e3,
+          // Use first 2KB of content
+          includeFilename: "character-knowledge"
+          // A constant identifier for character knowledge
+        });
         if (await this.checkExistingKnowledge(knowledgeId)) {
           logger4.debug(
             `KnowledgeService: Character knowledge item with ID ${knowledgeId} already exists. Skipping.`
@@ -1888,7 +1851,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
         await this._internalAddKnowledge(
           {
             id: knowledgeId,
-            // Use the content-derived ID
+            // Use the content-based ID
             content: {
               text: item
             },
@@ -3270,41 +3233,6 @@ var knowledgeActions = [processKnowledgeAction, searchKnowledgeAction];
 import { createUniqueUuid as createUniqueUuid2, logger as logger6, ModelType as ModelType4 } from "@elizaos/core";
 import fs3 from "fs";
 import path3 from "path";
-import multer from "multer";
-var createUploadMiddleware = (runtime) => {
-  const uploadDir = runtime.getSetting("KNOWLEDGE_UPLOAD_DIR") || "/tmp/uploads/";
-  const maxFileSize = parseInt(runtime.getSetting("KNOWLEDGE_MAX_FILE_SIZE") || "52428800");
-  const maxFiles = parseInt(runtime.getSetting("KNOWLEDGE_MAX_FILES") || "10");
-  const allowedMimeTypes = runtime.getSetting("KNOWLEDGE_ALLOWED_MIME_TYPES")?.split(",") || [
-    "text/plain",
-    "text/markdown",
-    "application/pdf",
-    "application/msword",
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    "text/html",
-    "application/json",
-    "application/xml",
-    "text/csv"
-  ];
-  return multer({
-    dest: uploadDir,
-    limits: {
-      fileSize: maxFileSize,
-      files: maxFiles
-    },
-    fileFilter: (req, file, cb) => {
-      if (allowedMimeTypes.includes(file.mimetype)) {
-        cb(null, true);
-      } else {
-        cb(
-          new Error(
-            `File type ${file.mimetype} not allowed. Allowed types: ${allowedMimeTypes.join(", ")}`
-          )
-        );
-      }
-    }
-  });
-};
 function sendSuccess(res, data, status = 200) {
   res.writeHead(status, { "Content-Type": "application/json" });
   res.end(JSON.stringify({ success: true, data }));
@@ -3324,7 +3252,11 @@ var cleanupFile = (filePath) => {
 };
 var cleanupFiles = (files) => {
   if (files) {
-    files.forEach((file) => cleanupFile(file.path));
+    files.forEach((file) => {
+      if (file.tempFilePath) {
+        cleanupFile(file.tempFilePath);
+      }
+    });
   }
 };
 async function uploadKnowledgeHandler(req, res, runtime) {
@@ -3332,20 +3264,61 @@ async function uploadKnowledgeHandler(req, res, runtime) {
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
-  const hasUploadedFiles = req.files && req.files.length > 0;
+  const hasUploadedFiles = req.files && Object.keys(req.files).length > 0;
   const isJsonRequest = !hasUploadedFiles && req.body && (req.body.fileUrl || req.body.fileUrls);
   if (!hasUploadedFiles && !isJsonRequest) {
     return sendError(res, 400, "INVALID_REQUEST", "Request must contain either files or URLs");
   }
   try {
     if (hasUploadedFiles) {
-      const files = req.files;
+      let files = [];
+      if (req.files.files) {
+        if (Array.isArray(req.files.files)) {
+          files = req.files.files;
+        } else {
+          files = [req.files.files];
+        }
+      } else if (req.files.file) {
+        files = [req.files.file];
+      } else {
+        files = Object.values(req.files).flat();
+      }
       if (!files || files.length === 0) {
         return sendError(res, 400, "NO_FILES", "No files uploaded");
       }
+      const invalidFiles = files.filter((file) => {
+        if (file.truncated) {
+          logger6.warn(`File ${file.name} was truncated during upload`);
+          return true;
+        }
+        if (file.size === 0) {
+          logger6.warn(`File ${file.name} is empty`);
+          return true;
+        }
+        if (!file.name || file.name.trim() === "") {
+          logger6.warn(`File has no name`);
+          return true;
+        }
+        if (!file.data && !file.tempFilePath) {
+          logger6.warn(`File ${file.name} has no data or temp file path`);
+          return true;
+        }
+        return false;
+      });
+      if (invalidFiles.length > 0) {
+        cleanupFiles(files);
+        const invalidFileNames = invalidFiles.map((f) => f.name || "unnamed").join(", ");
+        return sendError(
+          res,
+          400,
+          "INVALID_FILES",
+          `Invalid or corrupted files: ${invalidFileNames}`
+        );
+      }
       const agentId = req.body.agentId || req.query.agentId;
       if (!agentId) {
         logger6.error("[KNOWLEDGE UPLOAD HANDLER] No agent ID provided in request");
+        cleanupFiles(files);
         return sendError(
           res,
           400,
@@ -3356,25 +3329,53 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       const worldId = req.body.worldId || agentId;
       logger6.info(`[KNOWLEDGE UPLOAD HANDLER] Processing upload for agent: ${agentId}`);
       const processingPromises = files.map(async (file, index) => {
-        let knowledgeId;
-        const originalFilename = file.originalname;
-        const filePath = file.path;
-        knowledgeId = req.body?.documentIds && req.body.documentIds[index] || req.body?.documentId || createUniqueUuid2(runtime, `knowledge-${originalFilename}-${Date.now()}`);
+        const originalFilename = file.name;
+        const filePath = file.tempFilePath;
         logger6.debug(
-          `[KNOWLEDGE UPLOAD HANDLER] File: ${originalFilename}, Agent ID: ${agentId}, World ID: ${worldId}, Knowledge ID: ${knowledgeId}`
+          `[KNOWLEDGE UPLOAD HANDLER] File: ${originalFilename}, Agent ID: ${agentId}, World ID: ${worldId}`
         );
         try {
-          const fileBuffer = await fs3.promises.readFile(filePath);
+          let fileBuffer;
+          if (filePath && fs3.existsSync(filePath)) {
+            try {
+              const stats = await fs3.promises.stat(filePath);
+              if (stats.size === 0) {
+                throw new Error("Temporary file is empty");
+              }
+              fileBuffer = await fs3.promises.readFile(filePath);
+              logger6.debug(
+                `[KNOWLEDGE UPLOAD] Read ${fileBuffer.length} bytes from temp file: ${filePath}`
+              );
+            } catch (fsError) {
+              throw new Error(`Failed to read temporary file: ${fsError.message}`);
+            }
+          } else if (file.data && Buffer.isBuffer(file.data)) {
+            fileBuffer = file.data;
+            logger6.debug(`[KNOWLEDGE UPLOAD] Using in-memory buffer of ${fileBuffer.length} bytes`);
+          } else {
+            throw new Error("No file data available - neither temp file nor buffer found");
+          }
+          if (!Buffer.isBuffer(fileBuffer) || fileBuffer.length === 0) {
+            throw new Error("Invalid or empty file buffer");
+          }
+          if (fileBuffer.length !== file.size) {
+            logger6.warn(
+              `File size mismatch for ${originalFilename}: expected ${file.size}, got ${fileBuffer.length}`
+            );
+          }
           const base64Content = fileBuffer.toString("base64");
+          if (!base64Content || base64Content.length === 0) {
+            throw new Error("Failed to convert file to base64");
+          }
           const addKnowledgeOpts = {
             agentId,
             // Pass the agent ID from frontend
-            clientDocumentId: knowledgeId,
-            // This is knowledgeItem.id
+            clientDocumentId: "",
+            // This will be ignored by the service
             contentType: file.mimetype,
-            // Directly from multer file object
+            // Directly from express-fileupload file object
             originalFilename,
-            // Directly from multer file object
+            // Directly from express-fileupload file object
             content: base64Content,
             // The base64 string of the file
             worldId,
@@ -3383,10 +3384,13 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             entityId: agentId
             // Use the correct agent ID
           };
-          await service.addKnowledge(addKnowledgeOpts);
-          cleanupFile(filePath);
+          const result = await service.addKnowledge(addKnowledgeOpts);
+          if (filePath) {
+            cleanupFile(filePath);
+          }
           return {
-            id: knowledgeId,
+            id: result.clientDocumentId,
+            // Use the content-based ID returned by the service
             filename: originalFilename,
             type: file.mimetype,
             size: file.size,
@@ -3395,11 +3399,14 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           };
         } catch (fileError) {
           logger6.error(
-            `[KNOWLEDGE UPLOAD HANDLER] Error processing file ${file.originalname}: ${fileError}`
+            `[KNOWLEDGE UPLOAD HANDLER] Error processing file ${file.name}: ${fileError}`
           );
-          cleanupFile(filePath);
+          if (filePath) {
+            cleanupFile(filePath);
+          }
           return {
-            id: knowledgeId,
+            id: "",
+            // No ID since processing failed
             filename: originalFilename,
             status: "error_processing",
             error: fileError.message
@@ -3427,7 +3434,6 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       const processingPromises = fileUrls.map(async (fileUrl) => {
         try {
           const normalizedUrl = normalizeS3Url(fileUrl);
-          const knowledgeId = createUniqueUuid2(runtime, normalizedUrl);
           const urlObject = new URL(fileUrl);
           const pathSegments = urlObject.pathname.split("/");
           const encodedFilename = pathSegments[pathSegments.length - 1] || "document.pdf";
@@ -3458,7 +3464,8 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           const addKnowledgeOpts = {
             agentId,
             // Pass the agent ID from frontend
-            clientDocumentId: knowledgeId,
+            clientDocumentId: "",
+            // This will be ignored by the service
             contentType,
             originalFilename,
             content,
@@ -3477,6 +3484,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           const result = await service.addKnowledge(addKnowledgeOpts);
           return {
             id: result.clientDocumentId,
+            // Use the content-based ID returned by the service
             fileUrl,
             filename: originalFilename,
             message: "Knowledge created successfully",
@@ -3498,8 +3506,9 @@ async function uploadKnowledgeHandler(req, res, runtime) {
     }
   } catch (error) {
     logger6.error("[KNOWLEDGE HANDLER] Error processing knowledge:", error);
-    if (hasUploadedFiles) {
-      cleanupFiles(req.files);
+    if (hasUploadedFiles && req.files) {
+      const allFiles = Object.values(req.files).flat();
+      cleanupFiles(allFiles);
     }
     sendError(res, 500, "PROCESSING_ERROR", "Failed to process knowledge", error.message);
   }
@@ -3758,19 +3767,56 @@ async function getKnowledgeChunksHandler(req, res, runtime) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
   try {
-    const limit = req.query.limit ? Number.parseInt(req.query.limit, 10) : 100;
-    const before = req.query.before ? Number.parseInt(req.query.before, 10) : Date.now();
     const documentId = req.query.documentId;
-    const agentId = req.query.agentId;
-    const chunks = await service.getMemories({
-      tableName: "knowledge",
-      count: limit,
-      end: before
+    const documentsOnly = req.query.documentsOnly === "true";
+    const documents = await service.getMemories({
+      tableName: "documents",
+      count: 1e3,
+      // Reasonable limit for documents
+      end: Date.now()
+    });
+    if (documentsOnly) {
+      sendSuccess(res, {
+        chunks: documents,
+        stats: {
+          documents: documents.length,
+          fragments: 0,
+          mode: "documents-only"
+        }
+      });
+      return;
+    }
+    if (documentId) {
+      const allFragments = await service.getMemories({
+        tableName: "knowledge",
+        count: 1e5
+        // Very high limit to get all fragments
+      });
+      const documentFragments = allFragments.filter((fragment) => {
+        const metadata = fragment.metadata;
+        return metadata?.documentId === documentId;
+      });
+      const specificDocument = documents.find((d) => d.id === documentId);
+      const results = specificDocument ? [specificDocument, ...documentFragments] : documentFragments;
+      sendSuccess(res, {
+        chunks: results,
+        stats: {
+          documents: specificDocument ? 1 : 0,
+          fragments: documentFragments.length,
+          mode: "single-document",
+          documentId
+        }
+      });
+      return;
+    }
+    sendSuccess(res, {
+      chunks: documents,
+      stats: {
+        documents: documents.length,
+        fragments: 0,
+        mode: "documents-only"
+      }
     });
-    const filteredChunks = documentId ? chunks.filter(
-      (chunk) => chunk.metadata && typeof chunk.metadata === "object" && "documentId" in chunk.metadata && chunk.metadata.documentId === documentId
-    ) : chunks;
-    sendSuccess(res, { chunks: filteredChunks });
   } catch (error) {
     logger6.error("[KNOWLEDGE CHUNKS GET HANDLER] Error retrieving chunks:", error);
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve knowledge chunks", error.message);
@@ -3857,19 +3903,25 @@ async function searchKnowledgeHandler(req, res, runtime) {
     sendError(res, 500, "SEARCH_ERROR", "Failed to search knowledge", error.message);
   }
 }
-async function uploadKnowledgeWithMulter(req, res, runtime) {
-  const upload = createUploadMiddleware(runtime);
-  const uploadArray = upload.array(
-    "files",
-    parseInt(runtime.getSetting("KNOWLEDGE_MAX_FILES") || "10")
-  );
-  uploadArray(req, res, (err) => {
-    if (err) {
-      logger6.error("[KNOWLEDGE UPLOAD] Multer error:", err);
-      return sendError(res, 400, "UPLOAD_ERROR", err.message);
-    }
-    uploadKnowledgeHandler(req, res, runtime);
+async function handleKnowledgeUpload(req, res, runtime) {
+  logger6.debug("[KNOWLEDGE UPLOAD] Starting upload handler");
+  logger6.debug("[KNOWLEDGE UPLOAD] Request details:", {
+    method: req.method,
+    url: req.url,
+    contentType: req.headers["content-type"],
+    contentLength: req.headers["content-length"],
+    hasFiles: req.files ? Object.keys(req.files).length : 0,
+    hasBody: req.body ? Object.keys(req.body).length : 0
   });
+  try {
+    logger6.debug("[KNOWLEDGE UPLOAD] Using files parsed by global middleware");
+    await uploadKnowledgeHandler(req, res, runtime);
+  } catch (handlerError) {
+    logger6.error("[KNOWLEDGE UPLOAD] Handler error:", handlerError);
+    if (!res.headersSent) {
+      sendError(res, 500, "HANDLER_ERROR", "Failed to process upload");
+    }
+  }
 }
 var knowledgeRoutes = [
   {
@@ -3887,7 +3939,7 @@ var knowledgeRoutes = [
   {
     type: "POST",
     path: "/documents",
-    handler: uploadKnowledgeWithMulter
+    handler: handleKnowledgeUpload
   },
   {
     type: "GET",
@@ -3962,7 +4014,7 @@ var knowledgePlugin = {
             try {
               const service = runtime.getService(KnowledgeService.serviceType);
               if (service instanceof KnowledgeService) {
-                const { loadDocsFromPath: loadDocsFromPath2 } = await import("./docs-loader-IBTEOAYT.js");
+                const { loadDocsFromPath: loadDocsFromPath2 } = await import("./docs-loader-5INCF4VJ.js");
                 const result = await loadDocsFromPath2(service, runtime.agentId);
                 if (result.successful > 0) {
                   logger7.info(`Loaded ${result.successful} documents from docs folder on startup`);