@elizaos/plugin-knowledge 1.0.4 → 1.0.6

package/dist/index.js

@@ -4,8 +4,9 @@ import {
   fetchUrlContent,
   isBinaryContentType,
   loadDocsFromPath,
+  looksLikeBase64,
   normalizeS3Url
-} from "./chunk-BB6B27BS.js";
+} from "./chunk-536BD2UA.js";
 
 // src/index.ts
 import { logger as logger6 } from "@elizaos/core";
@@ -1152,6 +1153,7 @@ function createRateLimiter(requestsPerMinute) {
 var KnowledgeService = class _KnowledgeService extends Service {
   static serviceType = "knowledge";
   config;
+  knowledgeConfig;
   capabilityDescription = "Provides Retrieval Augmented Generation capabilities, including knowledge upload and querying.";
   knowledgeProcessingSemaphore;
   /**
@@ -1166,7 +1168,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
       if (typeof value === "string") return value.toLowerCase() === "true";
       return false;
     };
-    this.config = {
+    this.knowledgeConfig = {
       CTX_KNOWLEDGE_ENABLED: parseBooleanEnv(config?.CTX_KNOWLEDGE_ENABLED),
       LOAD_DOCS_ON_STARTUP: parseBooleanEnv(config?.LOAD_DOCS_ON_STARTUP),
       MAX_INPUT_TOKENS: config?.MAX_INPUT_TOKENS,
@@ -1175,11 +1177,12 @@ var KnowledgeService = class _KnowledgeService extends Service {
       TEXT_PROVIDER: config?.TEXT_PROVIDER,
       TEXT_EMBEDDING_MODEL: config?.TEXT_EMBEDDING_MODEL
     };
+    this.config = { ...this.knowledgeConfig };
     logger3.info(
       `KnowledgeService initialized for agent ${this.runtime.agentId} with config:`,
-      this.config
+      this.knowledgeConfig
     );
-    if (this.config.LOAD_DOCS_ON_STARTUP) {
+    if (this.knowledgeConfig.LOAD_DOCS_ON_STARTUP) {
       this.loadInitialDocuments().catch((error) => {
         logger3.error("Error during initial document loading in KnowledgeService:", error);
       });
@@ -1246,6 +1249,9 @@ var KnowledgeService = class _KnowledgeService extends Service {
     if (!service) {
       logger3.warn(`KnowledgeService not found for agent ${runtime.agentId} during stop.`);
     }
+    if (service instanceof _KnowledgeService) {
+      await service.stop();
+    }
   }
   /**
    * Stop the service
@@ -1259,9 +1265,9 @@ var KnowledgeService = class _KnowledgeService extends Service {
    * @returns Promise with document processing result
    */
   async addKnowledge(options) {
-    const agentId = this.runtime.agentId;
+    const agentId = options.agentId || this.runtime.agentId;
     logger3.info(
-      `KnowledgeService (agent: ${agentId}) processing document for public addKnowledge: ${options.originalFilename}, type: ${options.contentType}`
+      `KnowledgeService processing document for agent: ${agentId}, file: ${options.originalFilename}, type: ${options.contentType}`
     );
     try {
       const existingDocument = await this.runtime.getMemoryById(options.clientDocumentId);
@@ -1297,6 +1303,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
    * @returns Promise with document processing result
    */
   async processDocument({
+    agentId: passedAgentId,
     clientDocumentId,
     contentType,
     originalFilename,
@@ -1306,10 +1313,10 @@ var KnowledgeService = class _KnowledgeService extends Service {
     entityId,
     metadata
   }) {
-    const agentId = this.runtime.agentId;
+    const agentId = passedAgentId || this.runtime.agentId;
     try {
       logger3.debug(
-        `KnowledgeService: Processing document ${originalFilename} (type: ${contentType}) via processDocument`
+        `KnowledgeService: Processing document ${originalFilename} (type: ${contentType}) via processDocument for agent: ${agentId}`
       );
       let fileBuffer = null;
       let extractedText;
@@ -1338,9 +1345,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
         extractedText = await extractTextFromDocument(fileBuffer, contentType, originalFilename);
         documentContentToStore = extractedText;
       } else {
-        const base64Regex = /^[A-Za-z0-9+/]+=*$/;
-        const looksLikeBase64 = content && content.length > 0 && base64Regex.test(content.replace(/\s/g, ""));
-        if (looksLikeBase64) {
+        if (looksLikeBase64(content)) {
           try {
             const decodedBuffer = Buffer.from(content, "base64");
             const decodedText = decodedBuffer.toString("utf8");
@@ -1392,9 +1397,16 @@ var KnowledgeService = class _KnowledgeService extends Service {
         ...documentMemory,
         id: clientDocumentId,
         // Ensure the ID of the memory is the clientDocumentId
+        agentId,
         roomId: roomId || agentId,
         entityId: entityId || agentId
       };
+      logger3.debug(
+        `KnowledgeService: Creating memory with agentId=${agentId}, entityId=${entityId}, roomId=${roomId}, this.runtime.agentId=${this.runtime.agentId}`
+      );
+      logger3.debug(
+        `KnowledgeService: memoryWithScope agentId=${memoryWithScope.agentId}, entityId=${memoryWithScope.entityId}`
+      );
       await this.runtime.createMemory(memoryWithScope, "documents");
       logger3.debug(
         `KnowledgeService: Stored document ${originalFilename} (Memory ID: ${memoryWithScope.id})`
@@ -1665,16 +1677,10 @@ var KnowledgeService = class _KnowledgeService extends Service {
    * Corresponds to GET /plugins/knowledge/documents
    */
   async getMemories(params) {
-    if (params.tableName !== "documents") {
-      logger3.warn(
-        `KnowledgeService.getMemories called with tableName ${params.tableName}, but this service primarily manages 'documents'. Proceeding, but review usage.`
-      );
-    }
     return this.runtime.getMemories({
       ...params,
       // includes tableName, roomId, count, end
       agentId: this.runtime.agentId
-      // Ensure agentId is correctly scoped
     });
   }
   /**
@@ -2628,7 +2634,7 @@ var KnowledgeTestSuite = class {
 var tests_default = new KnowledgeTestSuite();
 
 // src/actions.ts
-import { logger as logger4, createUniqueUuid as createUniqueUuid2 } from "@elizaos/core";
+import { logger as logger4, stringToUuid } from "@elizaos/core";
 import * as fs2 from "fs";
 import * as path2 from "path";
 var processKnowledgeAction = {
@@ -2729,7 +2735,7 @@ var processKnowledgeAction = {
         else if ([".txt", ".md", ".tson", ".xml", ".csv"].includes(fileExt))
           contentType = "text/plain";
         const knowledgeOptions = {
-          clientDocumentId: createUniqueUuid2(runtime.agentId + fileName + Date.now(), fileName),
+          clientDocumentId: stringToUuid(runtime.agentId + fileName + Date.now()),
           contentType,
           originalFilename: fileName,
           worldId: runtime.agentId,
@@ -2756,7 +2762,7 @@ var processKnowledgeAction = {
           return;
         }
         const knowledgeOptions = {
-          clientDocumentId: createUniqueUuid2(runtime.agentId + "text" + Date.now(), "user-knowledge"),
+          clientDocumentId: stringToUuid(runtime.agentId + "text" + Date.now() + "user-knowledge"),
           contentType: "text/plain",
           originalFilename: "user-knowledge.txt",
           worldId: runtime.agentId,
@@ -2897,9 +2903,44 @@ ${formattedResults}`
 var knowledgeActions = [processKnowledgeAction, searchKnowledgeAction];
 
 // src/routes.ts
-import { MemoryType as MemoryType4, createUniqueUuid as createUniqueUuid3, logger as logger5 } from "@elizaos/core";
+import { createUniqueUuid as createUniqueUuid2, logger as logger5, 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 }));
@@ -2927,47 +2968,43 @@ async function uploadKnowledgeHandler(req, res, runtime) {
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
-  const isMultipartRequest = req.files && Object.keys(req.files).length > 0;
-  const isJsonRequest = !isMultipartRequest && req.body && (req.body.fileUrl || req.body.fileUrls);
-  if (!isMultipartRequest && !isJsonRequest) {
+  const hasUploadedFiles = req.files && 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 (isMultipartRequest) {
+    if (hasUploadedFiles) {
       const files = req.files;
       if (!files || files.length === 0) {
         return sendError(res, 400, "NO_FILES", "No files uploaded");
       }
+      const agentId = req.body.agentId || req.query.agentId;
+      if (!agentId) {
+        logger5.error("[KNOWLEDGE UPLOAD HANDLER] No agent ID provided in request");
+        return sendError(
+          res,
+          400,
+          "MISSING_AGENT_ID",
+          "Agent ID is required for uploading knowledge"
+        );
+      }
+      const worldId = req.body.worldId || agentId;
+      logger5.info(`[KNOWLEDGE UPLOAD HANDLER] Processing upload for agent: ${agentId}`);
       const processingPromises = files.map(async (file, index) => {
         let knowledgeId;
         const originalFilename = file.originalname;
-        const worldId = req.body.worldId || runtime.agentId;
         const filePath = file.path;
-        knowledgeId = req.body?.documentIds && req.body.documentIds[index] || req.body?.documentId || createUniqueUuid3(runtime, `knowledge-${originalFilename}-${Date.now()}`);
+        knowledgeId = req.body?.documentIds && req.body.documentIds[index] || req.body?.documentId || createUniqueUuid2(runtime, `knowledge-${originalFilename}-${Date.now()}`);
+        logger5.debug(
+          `[KNOWLEDGE UPLOAD HANDLER] File: ${originalFilename}, Agent ID: ${agentId}, World ID: ${worldId}, Knowledge ID: ${knowledgeId}`
+        );
         try {
           const fileBuffer = await fs3.promises.readFile(filePath);
-          const fileExt = file.originalname.split(".").pop()?.toLowerCase() || "";
-          const filename = file.originalname;
-          const title = filename.replace(`.${fileExt}`, "");
           const base64Content = fileBuffer.toString("base64");
-          const knowledgeItem = {
-            id: knowledgeId,
-            content: {
-              text: base64Content
-            },
-            metadata: {
-              type: MemoryType4.DOCUMENT,
-              timestamp: Date.now(),
-              source: "upload",
-              filename,
-              fileExt,
-              title,
-              path: originalFilename,
-              fileType: file.mimetype,
-              fileSize: file.size
-            }
-          };
           const addKnowledgeOpts = {
+            agentId,
+            // Pass the agent ID from frontend
             clientDocumentId: knowledgeId,
             // This is knowledgeItem.id
             contentType: file.mimetype,
@@ -2977,9 +3014,10 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             content: base64Content,
             // The base64 string of the file
             worldId,
-            roomId: runtime.agentId,
-            // Or a more specific room ID if available
-            entityId: runtime.agentId
+            roomId: agentId,
+            // Use the correct agent ID
+            entityId: agentId
+            // Use the correct agent ID
           };
           await service.addKnowledge(addKnowledgeOpts);
           cleanupFile(filePath);
@@ -3011,10 +3049,21 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       if (fileUrls.length === 0) {
         return sendError(res, 400, "MISSING_URL", "File URL is required");
       }
+      const agentId = req.body.agentId || req.query.agentId;
+      if (!agentId) {
+        logger5.error("[KNOWLEDGE URL HANDLER] No agent ID provided in request");
+        return sendError(
+          res,
+          400,
+          "MISSING_AGENT_ID",
+          "Agent ID is required for uploading knowledge from URLs"
+        );
+      }
+      logger5.info(`[KNOWLEDGE URL HANDLER] Processing URL upload for agent: ${agentId}`);
       const processingPromises = fileUrls.map(async (fileUrl) => {
         try {
           const normalizedUrl = normalizeS3Url(fileUrl);
-          const knowledgeId = createUniqueUuid3(runtime, normalizedUrl);
+          const knowledgeId = createUniqueUuid2(runtime, normalizedUrl);
           const urlObject = new URL(fileUrl);
           const pathSegments = urlObject.pathname.split("/");
           const encodedFilename = pathSegments[pathSegments.length - 1] || "document.pdf";
@@ -3043,20 +3092,24 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             }
           }
           const addKnowledgeOpts = {
+            agentId,
+            // Pass the agent ID from frontend
             clientDocumentId: knowledgeId,
             contentType,
             originalFilename,
             content,
             // Use the base64 encoded content from the URL
-            worldId: runtime.agentId,
-            roomId: runtime.agentId,
-            entityId: runtime.agentId,
+            worldId: agentId,
+            roomId: agentId,
+            entityId: agentId,
             // Store the normalized URL in metadata
             metadata: {
               url: normalizedUrl
             }
           };
-          logger5.debug(`[KNOWLEDGE URL HANDLER] Processing knowledge from URL: ${fileUrl} (type: ${contentType})`);
+          logger5.debug(
+            `[KNOWLEDGE URL HANDLER] Processing knowledge from URL: ${fileUrl} (type: ${contentType})`
+          );
           const result = await service.addKnowledge(addKnowledgeOpts);
           return {
             id: result.clientDocumentId,
@@ -3081,7 +3134,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
     }
   } catch (error) {
     logger5.error("[KNOWLEDGE HANDLER] Error processing knowledge:", error);
-    if (isMultipartRequest) {
+    if (hasUploadedFiles) {
       cleanupFiles(req.files);
     }
     sendError(res, 500, "PROCESSING_ERROR", "Failed to process knowledge", error.message);
@@ -3101,6 +3154,7 @@ async function getKnowledgeDocumentsHandler(req, res, runtime) {
     const limit = req.query.limit ? Number.parseInt(req.query.limit, 10) : 20;
     const before = req.query.before ? Number.parseInt(req.query.before, 10) : Date.now();
     const includeEmbedding = req.query.includeEmbedding === "true";
+    const agentId = req.query.agentId;
     const fileUrls = req.query.fileUrls ? typeof req.query.fileUrls === "string" && req.query.fileUrls.includes(",") ? req.query.fileUrls.split(",") : [req.query.fileUrls] : null;
     const memories = await service.getMemories({
       tableName: "documents",
@@ -3110,13 +3164,17 @@ async function getKnowledgeDocumentsHandler(req, res, runtime) {
     let filteredMemories = memories;
     if (fileUrls && fileUrls.length > 0) {
       const normalizedRequestUrls = fileUrls.map((url) => normalizeS3Url(url));
-      const urlBasedIds = normalizedRequestUrls.map((url) => createUniqueUuid3(runtime, url));
+      const urlBasedIds = normalizedRequestUrls.map(
+        (url) => createUniqueUuid2(runtime, url)
+      );
       filteredMemories = memories.filter(
         (memory) => urlBasedIds.includes(memory.id) || // If the ID corresponds directly
         // 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))
       );
-      logger5.debug(`[KNOWLEDGE GET HANDLER] Filtered documents by URLs: ${fileUrls.length} URLs, found ${filteredMemories.length} matching documents`);
+      logger5.debug(
+        `[KNOWLEDGE GET HANDLER] Filtered documents by URLs: ${fileUrls.length} URLs, found ${filteredMemories.length} matching documents`
+      );
     }
     const cleanMemories = includeEmbedding ? filteredMemories : filteredMemories.map((memory) => ({
       ...memory,
@@ -3154,9 +3212,13 @@ async function deleteKnowledgeDocumentHandler(req, res, runtime) {
   }
   try {
     const typedKnowledgeId = knowledgeId;
-    logger5.debug(`[KNOWLEDGE DELETE HANDLER] Attempting to delete document with ID: ${typedKnowledgeId}`);
+    logger5.debug(
+      `[KNOWLEDGE DELETE HANDLER] Attempting to delete document with ID: ${typedKnowledgeId}`
+    );
     await service.deleteMemory(typedKnowledgeId);
-    logger5.info(`[KNOWLEDGE DELETE HANDLER] Successfully deleted document with ID: ${typedKnowledgeId}`);
+    logger5.info(
+      `[KNOWLEDGE DELETE HANDLER] Successfully deleted document with ID: ${typedKnowledgeId}`
+    );
     sendSuccess(res, null, 204);
   } catch (error) {
     logger5.error(`[KNOWLEDGE DELETE HANDLER] Error deleting document ${knowledgeId}:`, error);
@@ -3184,6 +3246,7 @@ async function getKnowledgeByIdHandler(req, res, runtime) {
   }
   try {
     logger5.debug(`[KNOWLEDGE GET BY ID HANDLER] Retrieving document with ID: ${knowledgeId}`);
+    const agentId = req.query.agentId;
     const memories = await service.getMemories({
       tableName: "documents",
       count: 1e3
@@ -3205,9 +3268,11 @@ async function getKnowledgeByIdHandler(req, res, runtime) {
 }
 async function knowledgePanelHandler(req, res, runtime) {
   const agentId = runtime.agentId;
+  logger5.debug(`[KNOWLEDGE PANEL] Serving panel for agent ${agentId}, request path: ${req.path}`);
   try {
     const currentDir = path3.dirname(new URL(import.meta.url).pathname);
     const frontendPath = path3.join(currentDir, "../dist/index.html");
+    logger5.debug(`[KNOWLEDGE PANEL] Looking for frontend at: ${frontendPath}`);
     if (fs3.existsSync(frontendPath)) {
       const html = await fs3.promises.readFile(frontendPath, "utf8");
       const injectedHtml = html.replace(
@@ -3216,7 +3281,7 @@ async function knowledgePanelHandler(req, res, runtime) {
           <script>
             window.ELIZA_CONFIG = {
               agentId: '${agentId}',
-              apiBase: '/api/agents/${agentId}/plugins/knowledge'
+              apiBase: '/api'
             };
           </script>`
       );
@@ -3255,7 +3320,7 @@ async function knowledgePanelHandler(req, res, runtime) {
     <script>
       window.ELIZA_CONFIG = {
         agentId: '${agentId}',
-        apiBase: '/api/agents/${agentId}/plugins/knowledge'
+        apiBase: '/api'
       };
     </script>
     <link rel="stylesheet" href="./assets/${cssFile}">
@@ -3332,9 +3397,9 @@ async function getKnowledgeChunksHandler(req, res, runtime) {
     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",
-      // or whatever table stores the chunks
       count: limit,
       end: before
     });
@@ -3347,6 +3412,101 @@ async function getKnowledgeChunksHandler(req, res, runtime) {
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve knowledge chunks", error.message);
   }
 }
+async function searchKnowledgeHandler(req, res, runtime) {
+  const service = runtime.getService(KnowledgeService.serviceType);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
+  }
+  try {
+    const searchText = req.query.q;
+    const parsedThreshold = req.query.threshold ? Number.parseFloat(req.query.threshold) : NaN;
+    let matchThreshold = Number.isNaN(parsedThreshold) ? 0.5 : parsedThreshold;
+    matchThreshold = Math.max(0, Math.min(1, matchThreshold));
+    const parsedLimit = req.query.limit ? Number.parseInt(req.query.limit, 10) : NaN;
+    let limit = Number.isNaN(parsedLimit) ? 20 : parsedLimit;
+    limit = Math.max(1, Math.min(100, limit));
+    const agentId = req.query.agentId || runtime.agentId;
+    if (!searchText || searchText.trim().length === 0) {
+      return sendError(res, 400, "INVALID_QUERY", "Search query cannot be empty");
+    }
+    if (req.query.threshold && (parsedThreshold < 0 || parsedThreshold > 1)) {
+      logger5.debug(
+        `[KNOWLEDGE SEARCH] Threshold value ${parsedThreshold} was clamped to ${matchThreshold}`
+      );
+    }
+    if (req.query.limit && (parsedLimit < 1 || parsedLimit > 100)) {
+      logger5.debug(`[KNOWLEDGE SEARCH] Limit value ${parsedLimit} was clamped to ${limit}`);
+    }
+    logger5.debug(
+      `[KNOWLEDGE SEARCH] Searching for: "${searchText}" with threshold: ${matchThreshold}, limit: ${limit}`
+    );
+    const embedding = await runtime.useModel(ModelType4.TEXT_EMBEDDING, {
+      text: searchText
+    });
+    const results = await runtime.searchMemories({
+      tableName: "knowledge",
+      embedding,
+      query: searchText,
+      count: limit,
+      match_threshold: matchThreshold,
+      roomId: agentId
+    });
+    const enhancedResults = await Promise.all(
+      results.map(async (fragment) => {
+        let documentTitle = "Unknown Document";
+        let documentFilename = "unknown";
+        if (fragment.metadata && typeof fragment.metadata === "object" && "documentId" in fragment.metadata) {
+          const documentId = fragment.metadata.documentId;
+          try {
+            const document = await runtime.getMemoryById(documentId);
+            if (document && document.metadata) {
+              documentTitle = document.metadata.title || document.metadata.filename || documentTitle;
+              documentFilename = document.metadata.filename || documentFilename;
+            }
+          } catch (e) {
+            logger5.debug(`Could not fetch document ${documentId} for fragment`);
+          }
+        }
+        return {
+          id: fragment.id,
+          content: fragment.content,
+          similarity: fragment.similarity || 0,
+          metadata: {
+            ...fragment.metadata || {},
+            documentTitle,
+            documentFilename
+          }
+        };
+      })
+    );
+    logger5.info(
+      `[KNOWLEDGE SEARCH] Found ${enhancedResults.length} results for query: "${searchText}"`
+    );
+    sendSuccess(res, {
+      query: searchText,
+      threshold: matchThreshold,
+      results: enhancedResults,
+      count: enhancedResults.length
+    });
+  } catch (error) {
+    logger5.error("[KNOWLEDGE SEARCH] Error searching knowledge:", error);
+    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) {
+      logger5.error("[KNOWLEDGE UPLOAD] Multer error:", err);
+      return sendError(res, 400, "UPLOAD_ERROR", err.message);
+    }
+    uploadKnowledgeHandler(req, res, runtime);
+  });
+}
 var knowledgeRoutes = [
   {
     type: "GET",
@@ -3363,8 +3523,7 @@ var knowledgeRoutes = [
   {
     type: "POST",
     path: "/documents",
-    handler: uploadKnowledgeHandler,
-    isMultipart: true
+    handler: uploadKnowledgeWithMulter
   },
   {
     type: "GET",
@@ -3385,6 +3544,11 @@ var knowledgeRoutes = [
     type: "GET",
     path: "/knowledges",
     handler: getKnowledgeChunksHandler
+  },
+  {
+    type: "GET",
+    path: "/search",
+    handler: searchKnowledgeHandler
   }
 ];
 
@@ -3433,7 +3597,7 @@ var knowledgePlugin = {
             try {
               const service = runtime.getService(KnowledgeService.serviceType);
               if (service instanceof KnowledgeService) {
-                const { loadDocsFromPath: loadDocsFromPath2 } = await import("./docs-loader-NAE6ASGY.js");
+                const { loadDocsFromPath: loadDocsFromPath2 } = await import("./docs-loader-IBTEOAYT.js");
                 const result = await loadDocsFromPath2(service, runtime.agentId);
                 if (result.successful > 0) {
                   logger6.info(`Loaded ${result.successful} documents from docs folder on startup`);