@elizaos/plugin-knowledge 1.5.11 → 1.5.13

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/index.ts
+import { logger as logger11 } from "@elizaos/core";
+
 // src/service.ts
 import {
   createUniqueUuid,
@@ -3030,8 +3033,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";
@@ -3156,9 +3248,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;
       });
@@ -3172,7 +3264,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,
@@ -3544,7 +3636,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) {
@@ -3917,7 +4009,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 = {
@@ -3975,7 +4067,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;
@@ -4053,7 +4145,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"}`
       };
@@ -4144,7 +4236,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"}`
       };
@@ -4157,7 +4249,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";
@@ -4208,7 +4300,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}`);
     }
   }
 };
@@ -4235,15 +4327,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;
@@ -4260,7 +4352,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,
@@ -4269,11 +4361,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 {
@@ -4308,7 +4400,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             status: "success"
           };
         } catch (fileError) {
-          logger9.error(
+          logger10.error(
             `[Document Processor] \u274C Error processing file ${file.originalname}:`,
             fileError
           );
@@ -4331,7 +4423,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,
@@ -4339,7 +4431,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);
@@ -4347,7 +4439,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") {
@@ -4387,7 +4479,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);
@@ -4402,7 +4494,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",
@@ -4414,7 +4506,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);
     }
@@ -4453,7 +4545,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`
       );
     }
@@ -4468,12 +4560,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(
@@ -4485,22 +4577,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(
@@ -4512,11 +4604,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",
@@ -4533,20 +4625,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(
@@ -4582,10 +4674,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">
@@ -4619,14 +4711,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);
@@ -4647,7 +4739,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";
@@ -4662,7 +4754,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);
   }
 }
@@ -4723,7 +4815,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);
   }
 }
@@ -4745,14 +4837,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, {
@@ -4779,7 +4871,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 {
@@ -4794,7 +4886,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
         };
       })
     );
-    logger9.info(
+    logger10.info(
       `[Document Processor] \u{1F50D} Found ${enhancedResults.length} results for: "${searchText}"`
     );
     sendSuccess(res, {
@@ -4804,7 +4896,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);
   }
 }
@@ -4821,7 +4913,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({
@@ -4842,7 +4934,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" });
@@ -4854,9 +4946,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,
@@ -4872,17 +4964,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;
@@ -4891,7 +4983,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`
       );
     }
@@ -4906,7 +4998,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);
   }
 }
@@ -4921,24 +5013,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",
@@ -4952,25 +5044,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",
@@ -4984,10 +5076,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);
   }
 }
@@ -5002,7 +5094,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,
@@ -5010,33 +5102,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;
     });
@@ -5048,7 +5140,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,
@@ -5056,7 +5148,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);
   }
 }
@@ -5068,7 +5160,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);
@@ -5136,20 +5228,57 @@ var knowledgeRoutes = [
 ];
 
 // src/index.ts
-var knowledgePlugin = {
-  name: "knowledge",
-  description: "Plugin for Retrieval Augmented Generation, including knowledge management and embedding.",
-  services: [KnowledgeService],
-  providers: [knowledgeProvider],
-  routes: knowledgeRoutes,
-  actions: knowledgeActions,
-  tests: [tests_default]
-};
+function createKnowledgePlugin(config = {}) {
+  const { enableUI = true, enableRoutes = true, enableActions = true, enableTests = true } = config;
+  const plugin = {
+    name: "knowledge",
+    description: "Plugin for Retrieval Augmented Generation, including knowledge management and embedding.",
+    services: [KnowledgeService],
+    providers: [knowledgeProvider, documentsProvider]
+  };
+  if (enableUI || enableRoutes) {
+    plugin.routes = knowledgeRoutes;
+    logger11.debug("[Knowledge Plugin] Routes enabled");
+  } else {
+    logger11.info("[Knowledge Plugin] Running in headless mode (no routes or UI)");
+  }
+  if (enableActions) {
+    plugin.actions = knowledgeActions;
+  }
+  if (enableTests) {
+    plugin.tests = [tests_default];
+  }
+  return plugin;
+}
+var knowledgePluginCore = createKnowledgePlugin({
+  enableUI: false,
+  enableRoutes: false,
+  enableActions: false,
+  enableTests: false
+});
+var knowledgePluginHeadless = createKnowledgePlugin({
+  enableUI: false,
+  enableRoutes: false,
+  enableActions: true,
+  enableTests: false
+});
+var knowledgePlugin = createKnowledgePlugin({
+  enableUI: true,
+  enableRoutes: true,
+  enableActions: true,
+  enableTests: true
+});
 var index_default = knowledgePlugin;
 export {
+  KnowledgeService,
   KnowledgeServiceType,
   ModelConfigSchema,
+  createKnowledgePlugin,
   index_default as default,
-  knowledgePlugin
+  documentsProvider,
+  knowledgePlugin,
+  knowledgePluginCore,
+  knowledgePluginHeadless,
+  knowledgeProvider
 };
 //# sourceMappingURL=index.js.map