@elizaos/plugin-knowledge 1.0.11 → 1.2.1

package/dist/index.js

@@ -1,17 +1,147 @@
+// src/service.ts
 import {
-  convertPdfToTextFromBuffer,
-  extractTextFromFileBuffer,
-  fetchUrlContent,
-  generateContentBasedId,
-  isBinaryContentType,
-  loadDocsFromPath,
-  looksLikeBase64,
-  normalizeS3Url,
-  v4_default
-} from "./chunk-RFXW7QQK.js";
+  createUniqueUuid,
+  logger as logger6,
+  MemoryType as MemoryType2,
+  ModelType as ModelType2,
+  Semaphore,
+  Service,
+  splitChunks as splitChunks2
+} from "@elizaos/core";
 
-// src/index.ts
-import { logger as logger8 } from "@elizaos/core";
+// src/document-processor.ts
+import {
+  MemoryType,
+  ModelType,
+  logger as logger4,
+  splitChunks
+} from "@elizaos/core";
+
+// node_modules/uuid/dist/esm/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
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default = validate;
+
+// node_modules/uuid/dist/esm/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
+}
+var parse_default = parse;
+
+// 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/v35.js
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str));
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; ++i) {
+    bytes[i] = str.charCodeAt(i);
+  }
+  return bytes;
+}
+var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+var URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+function v35(version, hash, value, namespace, buf, offset) {
+  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
+  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
+  if (typeof namespace === "string") {
+    namespace = parse_default(namespace);
+  }
+  if (namespace?.length !== 16) {
+    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+  }
+  let bytes = new Uint8Array(16 + valueBytes.length);
+  bytes.set(namespaceBytes);
+  bytes.set(valueBytes, namespaceBytes.length);
+  bytes = hash(bytes);
+  bytes[6] = bytes[6] & 15 | version;
+  bytes[8] = bytes[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = bytes[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(bytes);
+}
+
+// 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();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// node_modules/uuid/dist/esm/sha1.js
+import { createHash } from "crypto";
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return createHash("sha1").update(bytes).digest();
+}
+var sha1_default = sha1;
+
+// node_modules/uuid/dist/esm/v5.js
+function v5(value, namespace, buf, offset) {
+  return v35(80, sha1_default, value, namespace, buf, offset);
+}
+v5.DNS = DNS;
+v5.URL = URL2;
+var v5_default = v5;
 
 // src/types.ts
 import z from "zod";
@@ -42,6 +172,8 @@ var ModelConfigSchema = z.object({
   // For OpenAI: Only applies to text-embedding-3-small and text-embedding-3-large models
   // Default: 1536 dimensions
   EMBEDDING_DIMENSION: z.string().or(z.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 1536),
+  // config setting
+  LOAD_DOCS_ON_STARTUP: z.boolean().default(false),
   // Contextual Knowledge settings
   CTX_KNOWLEDGE_ENABLED: z.boolean().default(false)
 });
@@ -52,19 +184,22 @@ var KnowledgeServiceType = {
 // src/config.ts
 import z2 from "zod";
 import { logger } from "@elizaos/core";
+var parseBooleanEnv = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toLowerCase() === "true";
+  return false;
+};
 function validateModelConfig(runtime) {
   try {
     const getSetting = (key, defaultValue) => {
       if (runtime) {
-        return runtime.getSetting(key) || defaultValue;
+        return runtime.getSetting(key) || process.env[key] || defaultValue;
       }
       return process.env[key] || defaultValue;
     };
-    const ctxKnowledgeEnabledSetting = getSetting("CTX_KNOWLEDGE_ENABLED");
-    const cleanSetting = ctxKnowledgeEnabledSetting?.toString().trim().toLowerCase();
-    const ctxKnowledgeEnabled = cleanSetting === "true";
+    const ctxKnowledgeEnabled = parseBooleanEnv(getSetting("CTX_KNOWLEDGE_ENABLED", "false"));
     logger.debug(
-      `[Document Processor] CTX_KNOWLEDGE_ENABLED: '${ctxKnowledgeEnabledSetting}' \u2192 ${ctxKnowledgeEnabled} (runtime: ${!!runtime})`
+      `[Document Processor] CTX_KNOWLEDGE_ENABLED: '${ctxKnowledgeEnabled} (runtime: ${!!runtime})`
     );
     const embeddingProvider = getSetting("EMBEDDING_PROVIDER");
     const assumePluginOpenAI = !embeddingProvider;
@@ -101,6 +236,7 @@ function validateModelConfig(runtime) {
       MAX_INPUT_TOKENS: getSetting("MAX_INPUT_TOKENS", "4000"),
       MAX_OUTPUT_TOKENS: getSetting("MAX_OUTPUT_TOKENS", "4096"),
       EMBEDDING_DIMENSION: embeddingDimension,
+      LOAD_DOCS_ON_STARTUP: parseBooleanEnv(getSetting("LOAD_DOCS_ON_STARTUP")),
       CTX_KNOWLEDGE_ENABLED: ctxKnowledgeEnabled
     });
     validateConfigRequirements(config, assumePluginOpenAI);
@@ -212,25 +348,6 @@ async function getProviderRateLimits(runtime) {
   }
 }
 
-// src/service.ts
-import {
-  createUniqueUuid,
-  logger as logger4,
-  MemoryType as MemoryType2,
-  ModelType as ModelType2,
-  Semaphore,
-  Service,
-  splitChunks as splitChunks2
-} from "@elizaos/core";
-
-// src/document-processor.ts
-import {
-  MemoryType,
-  ModelType,
-  logger as logger3,
-  splitChunks
-} from "@elizaos/core";
-
 // src/ctx-embeddings.ts
 var DEFAULT_CHUNK_TOKEN_SIZE = 500;
 var DEFAULT_CHUNK_OVERLAP_TOKENS = 100;
@@ -646,8 +763,8 @@ import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 import { google } from "@ai-sdk/google";
 import { logger as logger2 } from "@elizaos/core";
-async function generateText(prompt, system, overrideConfig) {
-  const config = validateModelConfig();
+async function generateText(runtime, prompt, system, overrideConfig) {
+  const config = validateModelConfig(runtime);
   const provider = overrideConfig?.provider || config.TEXT_PROVIDER;
   const modelName = overrideConfig?.modelName || config.TEXT_MODEL;
   const maxTokens = overrideConfig?.maxTokens || config.MAX_OUTPUT_TOKENS;
@@ -655,11 +772,12 @@ async function generateText(prompt, system, overrideConfig) {
   try {
     switch (provider) {
       case "anthropic":
-        return await generateAnthropicText(prompt, system, modelName, maxTokens);
+        return await generateAnthropicText(config, prompt, system, modelName, maxTokens);
       case "openai":
-        return await generateOpenAIText(prompt, system, modelName, maxTokens);
+        return await generateOpenAIText(config, prompt, system, modelName, maxTokens);
       case "openrouter":
         return await generateOpenRouterText(
+          config,
           prompt,
           system,
           modelName,
@@ -678,8 +796,7 @@ async function generateText(prompt, system, overrideConfig) {
     throw error;
   }
 }
-async function generateAnthropicText(prompt, system, modelName, maxTokens) {
-  const config = validateModelConfig();
+async function generateAnthropicText(config, prompt, system, modelName, maxTokens) {
   const anthropic = createAnthropic({
     apiKey: config.ANTHROPIC_API_KEY,
     baseURL: config.ANTHROPIC_BASE_URL
@@ -707,7 +824,7 @@ async function generateAnthropicText(prompt, system, modelName, maxTokens) {
         logger2.warn(
           `[Document Processor] Rate limit hit (${modelName}): attempt ${attempt + 1}/${maxRetries}, retrying in ${Math.round(delay / 1e3)}s`
         );
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
         continue;
       }
       throw error;
@@ -715,8 +832,7 @@ async function generateAnthropicText(prompt, system, modelName, maxTokens) {
   }
   throw new Error("Max retries exceeded for Anthropic text generation");
 }
-async function generateOpenAIText(prompt, system, modelName, maxTokens) {
-  const config = validateModelConfig();
+async function generateOpenAIText(config, prompt, system, modelName, maxTokens) {
   const openai = createOpenAI({
     apiKey: config.OPENAI_API_KEY,
     baseURL: config.OPENAI_BASE_URL
@@ -754,8 +870,7 @@ async function generateGoogleText(prompt, system, modelName, maxTokens, config)
   );
   return result;
 }
-async function generateOpenRouterText(prompt, system, modelName, maxTokens, cacheDocument, cacheOptions, autoCacheContextualRetrieval = true) {
-  const config = validateModelConfig();
+async function generateOpenRouterText(config, prompt, system, modelName, maxTokens, cacheDocument, cacheOptions, autoCacheContextualRetrieval = true) {
   const openrouter = createOpenRouter({
     apiKey: config.OPENROUTER_API_KEY,
     baseURL: config.OPENROUTER_BASE_URL
@@ -962,6 +1077,359 @@ function logCacheMetrics(result) {
   }
 }
 
+// src/utils.ts
+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 { createHash as createHash2 } from "crypto";
+var PLAIN_TEXT_CONTENT_TYPES = [
+  "application/typescript",
+  "text/typescript",
+  "text/x-python",
+  "application/x-python-code",
+  "application/yaml",
+  "text/yaml",
+  "application/x-yaml",
+  "application/json",
+  "text/markdown",
+  "text/csv"
+];
+var MAX_FALLBACK_SIZE_BYTES = 5 * 1024 * 1024;
+var BINARY_CHECK_BYTES = 1024;
+async function extractTextFromFileBuffer(fileBuffer, contentType, originalFilename) {
+  const lowerContentType = contentType.toLowerCase();
+  logger3.debug(
+    `[TextUtil] Attempting to extract text from ${originalFilename} (type: ${contentType})`
+  );
+  if (lowerContentType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
+    logger3.debug(`[TextUtil] Extracting text from DOCX ${originalFilename} via mammoth.`);
+    try {
+      const result = await mammoth.extractRawText({ buffer: fileBuffer });
+      logger3.debug(
+        `[TextUtil] DOCX text extraction complete for ${originalFilename}. Text length: ${result.value.length}`
+      );
+      return result.value;
+    } catch (docxError) {
+      const errorMsg = `[TextUtil] Failed to parse DOCX file ${originalFilename}: ${docxError.message}`;
+      logger3.error(errorMsg, docxError.stack);
+      throw new Error(errorMsg);
+    }
+  } else if (lowerContentType === "application/msword" || originalFilename.toLowerCase().endsWith(".doc")) {
+    logger3.debug(`[TextUtil] Handling Microsoft Word .doc file: ${originalFilename}`);
+    return `[Microsoft Word Document: ${originalFilename}]
+
+This document was indexed for search but cannot be displayed directly in the browser. The original document content is preserved for retrieval purposes.`;
+  } else if (lowerContentType.startsWith("text/") || PLAIN_TEXT_CONTENT_TYPES.includes(lowerContentType)) {
+    logger3.debug(
+      `[TextUtil] Extracting text from plain text compatible file ${originalFilename} (type: ${contentType})`
+    );
+    return fileBuffer.toString("utf-8");
+  } else {
+    logger3.warn(
+      `[TextUtil] Unsupported content type: "${contentType}" for ${originalFilename}. Attempting fallback to plain text.`
+    );
+    if (fileBuffer.length > MAX_FALLBACK_SIZE_BYTES) {
+      const sizeErrorMsg = `[TextUtil] File ${originalFilename} (type: ${contentType}) exceeds maximum size for fallback (${MAX_FALLBACK_SIZE_BYTES} bytes). Cannot process as plain text.`;
+      logger3.error(sizeErrorMsg);
+      throw new Error(sizeErrorMsg);
+    }
+    const initialBytes = fileBuffer.subarray(0, Math.min(fileBuffer.length, BINARY_CHECK_BYTES));
+    if (initialBytes.includes(0)) {
+      const binaryHeuristicMsg = `[TextUtil] File ${originalFilename} (type: ${contentType}) appears to be binary based on initial byte check. Cannot process as plain text.`;
+      logger3.error(binaryHeuristicMsg);
+      throw new Error(binaryHeuristicMsg);
+    }
+    try {
+      const textContent = fileBuffer.toString("utf-8");
+      if (textContent.includes("\uFFFD")) {
+        const binaryErrorMsg = `[TextUtil] File ${originalFilename} (type: ${contentType}) seems to be binary or has encoding issues after fallback to plain text (detected \uFFFD).`;
+        logger3.error(binaryErrorMsg);
+        throw new Error(binaryErrorMsg);
+      }
+      logger3.debug(
+        `[TextUtil] Successfully processed unknown type ${contentType} as plain text after fallback for ${originalFilename}.`
+      );
+      return textContent;
+    } catch (fallbackError) {
+      const finalErrorMsg = `[TextUtil] Unsupported content type: ${contentType} for ${originalFilename}. Fallback to plain text also failed or indicated binary content.`;
+      logger3.error(finalErrorMsg, fallbackError.message ? fallbackError.stack : void 0);
+      throw new Error(finalErrorMsg);
+    }
+  }
+}
+async function convertPdfToTextFromBuffer(pdfBuffer, filename) {
+  const docName = filename || "unnamed-document";
+  logger3.debug(`[PdfService] Starting conversion for ${docName}`);
+  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 fullText = textPages.join("\n\n").replace(/\s+/g, " ").trim();
+    logger3.debug(`[PdfService] Conversion complete for ${docName}, length: ${fullText.length}`);
+    return fullText;
+  } catch (error) {
+    logger3.error(`[PdfService] Error converting PDF ${docName}:`, error.message);
+    throw new Error(`Failed to convert PDF to text: ${error.message}`);
+  }
+}
+function isBinaryContentType(contentType, filename) {
+  const textContentTypes = [
+    "text/",
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/typescript",
+    "application/x-yaml",
+    "application/x-sh"
+  ];
+  const isTextMimeType = textContentTypes.some((type) => contentType.includes(type));
+  if (isTextMimeType) {
+    return false;
+  }
+  const binaryContentTypes = [
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument",
+    "application/vnd.ms-excel",
+    "application/vnd.ms-powerpoint",
+    "application/zip",
+    "application/x-zip-compressed",
+    "application/octet-stream",
+    "image/",
+    "audio/",
+    "video/"
+  ];
+  const isBinaryMimeType = binaryContentTypes.some((type) => contentType.includes(type));
+  if (isBinaryMimeType) {
+    return true;
+  }
+  const fileExt = filename.split(".").pop()?.toLowerCase() || "";
+  const textExtensions = [
+    "txt",
+    "md",
+    "markdown",
+    "json",
+    "xml",
+    "html",
+    "htm",
+    "css",
+    "js",
+    "ts",
+    "jsx",
+    "tsx",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "cfg",
+    "conf",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "py",
+    "rb",
+    "go",
+    "rs",
+    "java",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "cs",
+    "php",
+    "sql",
+    "r",
+    "swift",
+    "kt",
+    "scala",
+    "clj",
+    "ex",
+    "exs",
+    "vim",
+    "env",
+    "gitignore",
+    "dockerignore",
+    "editorconfig",
+    "log",
+    "csv",
+    "tsv",
+    "properties",
+    "gradle",
+    "sbt",
+    "makefile",
+    "dockerfile",
+    "vagrantfile",
+    "gemfile",
+    "rakefile",
+    "podfile",
+    "csproj",
+    "vbproj",
+    "fsproj",
+    "sln",
+    "pom"
+  ];
+  if (textExtensions.includes(fileExt)) {
+    return false;
+  }
+  const binaryExtensions = [
+    "pdf",
+    "docx",
+    "doc",
+    "xls",
+    "xlsx",
+    "ppt",
+    "pptx",
+    "zip",
+    "rar",
+    "7z",
+    "tar",
+    "gz",
+    "bz2",
+    "xz",
+    "jpg",
+    "jpeg",
+    "png",
+    "gif",
+    "bmp",
+    "svg",
+    "ico",
+    "webp",
+    "mp3",
+    "mp4",
+    "avi",
+    "mov",
+    "wmv",
+    "flv",
+    "wav",
+    "flac",
+    "ogg",
+    "exe",
+    "dll",
+    "so",
+    "dylib",
+    "bin",
+    "dat",
+    "db",
+    "sqlite"
+  ];
+  return binaryExtensions.includes(fileExt);
+}
+function isTextItem(item) {
+  return "str" in item;
+}
+function normalizeS3Url(url) {
+  try {
+    const urlObj = new URL(url);
+    return `${urlObj.origin}${urlObj.pathname}`;
+  } catch (error) {
+    logger3.warn(`[URL NORMALIZER] Failed to parse URL: ${url}. Returning original.`);
+    return url;
+  }
+}
+async function fetchUrlContent(url) {
+  logger3.debug(`[URL FETCHER] Fetching content from URL: ${url}`);
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "Eliza-Knowledge-Plugin/1.0"
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch URL: ${response.status} ${response.statusText}`);
+    }
+    const contentType = response.headers.get("content-type") || "application/octet-stream";
+    logger3.debug(`[URL FETCHER] Content type from server: ${contentType} for URL: ${url}`);
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer2.from(arrayBuffer);
+    const base64Content = buffer.toString("base64");
+    logger3.debug(
+      `[URL FETCHER] Successfully fetched content from URL: ${url} (${buffer.length} bytes)`
+    );
+    return {
+      content: base64Content,
+      contentType
+    };
+  } catch (error) {
+    logger3.error(`[URL FETCHER] Error fetching content from URL ${url}: ${error.message}`);
+    throw new Error(`Failed to fetch content from URL: ${error.message}`);
+  }
+}
+function looksLikeBase64(content) {
+  if (!content || content.length === 0) return false;
+  const cleanContent = content.replace(/\s/g, "");
+  if (cleanContent.length < 16) return false;
+  if (cleanContent.length % 4 !== 0) return false;
+  const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+  if (!base64Regex.test(cleanContent)) return false;
+  const hasNumbers = /\d/.test(cleanContent);
+  const hasUpperCase = /[A-Z]/.test(cleanContent);
+  const hasLowerCase = /[a-z]/.test(cleanContent);
+  return (hasNumbers || hasUpperCase) && hasLowerCase;
+}
+function generateContentBasedId(content, agentId, options) {
+  const {
+    maxChars = 2e3,
+    // Use first 2000 chars by default
+    includeFilename,
+    contentType
+  } = options || {};
+  let contentForHashing;
+  if (looksLikeBase64(content)) {
+    try {
+      const decoded = Buffer2.from(content, "base64").toString("utf8");
+      if (!decoded.includes("\uFFFD") || contentType?.includes("pdf")) {
+        contentForHashing = content.slice(0, maxChars);
+      } else {
+        contentForHashing = decoded.slice(0, maxChars);
+      }
+    } catch {
+      contentForHashing = content.slice(0, maxChars);
+    }
+  } else {
+    contentForHashing = content.slice(0, maxChars);
+  }
+  contentForHashing = contentForHashing.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+  const componentsToHash = [
+    agentId,
+    // Namespace by agent
+    contentForHashing,
+    // The actual content
+    includeFilename || ""
+    // Optional filename for additional uniqueness
+  ].filter(Boolean).join("::");
+  const hash = createHash2("sha256").update(componentsToHash).digest("hex");
+  const DOCUMENT_NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+  const uuid = v5_default(hash, DOCUMENT_NAMESPACE);
+  logger3.debug(
+    `[generateContentBasedId] Generated UUID ${uuid} for document with content hash ${hash.slice(0, 8)}...`
+  );
+  return uuid;
+}
+
 // src/document-processor.ts
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
@@ -982,7 +1450,7 @@ function getCtxKnowledgeEnabled(runtime) {
     source = "process.env";
   }
   if (process.env.NODE_ENV === "development" && rawValue && !result) {
-    logger3.debug(`[Document Processor] CTX config mismatch - ${source}: '${rawValue}' \u2192 ${result}`);
+    logger4.debug(`[Document Processor] CTX config mismatch - ${source}: '${rawValue}' \u2192 ${result}`);
   }
   return result;
 }
@@ -1018,23 +1486,23 @@ async function processFragmentsSynchronously({
   documentTitle
 }) {
   if (!fullDocumentText || fullDocumentText.trim() === "") {
-    logger3.warn(`No text content available to chunk for document ${documentId}.`);
+    logger4.warn(`No text content available to chunk for document ${documentId}.`);
     return 0;
   }
   const chunks = await splitDocumentIntoChunks(fullDocumentText);
   if (chunks.length === 0) {
-    logger3.warn(`No chunks generated from text for ${documentId}. No fragments to save.`);
+    logger4.warn(`No chunks generated from text for ${documentId}. No fragments to save.`);
     return 0;
   }
   const docName = documentTitle || documentId.substring(0, 8);
-  logger3.info(`[Document Processor] "${docName}": Split into ${chunks.length} chunks`);
+  logger4.info(`[Document Processor] "${docName}": Split into ${chunks.length} chunks`);
   const providerLimits = await getProviderRateLimits();
   const CONCURRENCY_LIMIT = Math.min(30, providerLimits.maxConcurrentRequests || 30);
   const rateLimiter = createRateLimiter(
     providerLimits.requestsPerMinute || 60,
     providerLimits.tokensPerMinute
   );
-  logger3.debug(
+  logger4.debug(
     `[Document Processor] Rate limits: ${providerLimits.requestsPerMinute} RPM, ${providerLimits.tokensPerMinute} TPM (${providerLimits.provider}, concurrency: ${CONCURRENCY_LIMIT})`
   );
   const { savedCount, failedCount } = await processAndSaveFragments({
@@ -1053,11 +1521,11 @@ async function processFragmentsSynchronously({
   });
   const successRate = (savedCount / chunks.length * 100).toFixed(1);
   if (failedCount > 0) {
-    logger3.warn(
+    logger4.warn(
       `[Document Processor] "${docName}": ${failedCount}/${chunks.length} chunks failed processing`
     );
   }
-  logger3.info(
+  logger4.info(
     `[Document Processor] "${docName}" complete: ${savedCount}/${chunks.length} fragments saved (${successRate}% success)`
   );
   logKnowledgeGenerationSummary({
@@ -1077,15 +1545,15 @@ async function extractTextFromDocument(fileBuffer, contentType, originalFilename
   }
   try {
     if (contentType === "application/pdf") {
-      logger3.debug(`Extracting text from PDF: ${originalFilename}`);
+      logger4.debug(`Extracting text from PDF: ${originalFilename}`);
       return await convertPdfToTextFromBuffer(fileBuffer, originalFilename);
     } else {
-      logger3.debug(`Extracting text from non-PDF: ${originalFilename} (Type: ${contentType})`);
+      logger4.debug(`Extracting text from non-PDF: ${originalFilename} (Type: ${contentType})`);
       if (contentType.includes("text/") || contentType.includes("application/json") || contentType.includes("application/xml")) {
         try {
           return fileBuffer.toString("utf8");
         } catch (textError) {
-          logger3.warn(
+          logger4.warn(
             `Failed to decode ${originalFilename} as UTF-8, falling back to binary extraction`
           );
         }
@@ -1093,7 +1561,7 @@ async function extractTextFromDocument(fileBuffer, contentType, originalFilename
       return await extractTextFromFileBuffer(fileBuffer, contentType, originalFilename);
     }
   } catch (error) {
-    logger3.error(`Error extracting text from ${originalFilename}: ${error.message}`);
+    logger4.error(`Error extracting text from ${originalFilename}: ${error.message}`);
     throw new Error(`Failed to extract text from ${originalFilename}: ${error.message}`);
   }
 }
@@ -1138,7 +1606,7 @@ async function splitDocumentIntoChunks(documentText) {
   const tokenChunkOverlap = DEFAULT_CHUNK_OVERLAP_TOKENS;
   const targetCharChunkSize = Math.round(tokenChunkSize * DEFAULT_CHARS_PER_TOKEN);
   const targetCharChunkOverlap = Math.round(tokenChunkOverlap * DEFAULT_CHARS_PER_TOKEN);
-  logger3.debug(
+  logger4.debug(
     `Using core splitChunks with settings: tokenChunkSize=${tokenChunkSize}, tokenChunkOverlap=${tokenChunkOverlap}, charChunkSize=${targetCharChunkSize}, charChunkOverlap=${targetCharChunkOverlap}`
   );
   return await splitChunks(documentText, tokenChunkSize, tokenChunkOverlap);
@@ -1163,7 +1631,7 @@ async function processAndSaveFragments({
   for (let i = 0; i < chunks.length; i += concurrencyLimit) {
     const batchChunks = chunks.slice(i, i + concurrencyLimit);
     const batchOriginalIndices = Array.from({ length: batchChunks.length }, (_, k) => i + k);
-    logger3.debug(
+    logger4.debug(
       `[Document Processor] Batch ${Math.floor(i / concurrencyLimit) + 1}/${Math.ceil(chunks.length / concurrencyLimit)}: processing ${batchChunks.length} chunks (${batchOriginalIndices[0]}-${batchOriginalIndices[batchOriginalIndices.length - 1]})`
     );
     const contextualizedChunks = await getContextualizedChunks(
@@ -1184,13 +1652,13 @@ async function processAndSaveFragments({
       if (!result.success) {
         failedCount++;
         failedChunks.push(originalChunkIndex);
-        logger3.warn(`Failed to process chunk ${originalChunkIndex} for document ${documentId}`);
+        logger4.warn(`Failed to process chunk ${originalChunkIndex} for document ${documentId}`);
         continue;
       }
       const contextualizedChunkText = result.text;
       const embedding = result.embedding;
       if (!embedding || embedding.length === 0) {
-        logger3.warn(
+        logger4.warn(
           `Zero vector detected for chunk ${originalChunkIndex} (document ${documentId}). Embedding: ${JSON.stringify(result.embedding)}`
         );
         failedCount++;
@@ -1217,13 +1685,13 @@ async function processAndSaveFragments({
         await runtime.createMemory(fragmentMemory, "knowledge");
         if (originalChunkIndex === chunks.length - 1) {
           const docName = documentTitle || documentId.substring(0, 8);
-          logger3.info(
+          logger4.info(
             `[Document Processor] "${docName}": All ${chunks.length} chunks processed successfully`
           );
         }
         savedCount++;
       } catch (saveError) {
-        logger3.error(
+        logger4.error(
           `Error saving chunk ${originalChunkIndex} to database: ${saveError.message}`,
           saveError.stack
         );
@@ -1232,7 +1700,7 @@ async function processAndSaveFragments({
       }
     }
     if (i + concurrencyLimit < chunks.length) {
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      await new Promise((resolve2) => setTimeout(resolve2, 500));
     }
   }
   return { savedCount, failedCount, failedChunks };
@@ -1286,7 +1754,7 @@ async function generateEmbeddingsForChunks(runtime, contextualizedChunks, rateLi
           text: contextualizedChunk.contextualizedText
         };
       } catch (error) {
-        logger3.error(
+        logger4.error(
           `Error generating embedding for chunk ${contextualizedChunk.index}: ${error.message}`
         );
         return {
@@ -1305,7 +1773,7 @@ async function getContextualizedChunks(runtime, fullDocumentText, chunks, conten
     const docName = documentTitle || "Document";
     const provider = runtime?.getSetting("TEXT_PROVIDER") || process.env.TEXT_PROVIDER;
     const model = runtime?.getSetting("TEXT_MODEL") || process.env.TEXT_MODEL;
-    logger3.info(
+    logger4.info(
       `[Document Processor] "${docName}": CTX enrichment ${ctxEnabled ? "ENABLED" : "DISABLED"}${ctxEnabled ? ` (${provider}/${model})` : ""}`
     );
   }
@@ -1319,7 +1787,7 @@ async function getContextualizedChunks(runtime, fullDocumentText, chunks, conten
       documentTitle
     );
   } else if (!ctxEnabled && batchOriginalIndices[0] === 0) {
-    logger3.debug(
+    logger4.debug(
       `[Document Processor] To enable CTX: Set CTX_KNOWLEDGE_ENABLED=true and configure TEXT_PROVIDER/TEXT_MODEL`
     );
   }
@@ -1338,10 +1806,10 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
     providerLimits.requestsPerMinute || 60,
     providerLimits.tokensPerMinute
   );
-  const config = validateModelConfig();
+  const config = validateModelConfig(runtime);
   const isUsingOpenRouter = config.TEXT_PROVIDER === "openrouter";
   const isUsingCacheCapableModel = isUsingOpenRouter && (config.TEXT_MODEL?.toLowerCase().includes("claude") || config.TEXT_MODEL?.toLowerCase().includes("gemini"));
-  logger3.debug(
+  logger4.debug(
     `[Document Processor] Contextualizing ${chunks.length} chunks with ${config.TEXT_PROVIDER}/${config.TEXT_MODEL} (cache: ${isUsingCacheCapableModel})`
   );
   const promptConfigs = prepareContextPrompts(
@@ -1367,13 +1835,13 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
         const generateTextOperation = async () => {
           if (useCustomLLM) {
             if (item.usesCaching) {
-              return await generateText(item.promptText, item.systemPrompt, {
+              return await generateText(runtime, item.promptText, item.systemPrompt, {
                 cacheDocument: item.fullDocumentTextForContext,
                 cacheOptions: { type: "ephemeral" },
                 autoCacheContextualRetrieval: true
               });
             } else {
-              return await generateText(item.prompt);
+              return await generateText(runtime, item.prompt);
             }
           } else {
             if (item.usesCaching) {
@@ -1396,7 +1864,7 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
         const contextualizedText = getChunkWithContext(item.chunkText, generatedContext);
         if ((item.originalIndex + 1) % Math.max(1, Math.floor(chunks.length / 3)) === 0 || item.originalIndex === chunks.length - 1) {
           const docName = documentTitle || "Document";
-          logger3.debug(
+          logger4.debug(
             `[Document Processor] "${docName}": Context added for ${item.originalIndex + 1}/${chunks.length} chunks`
           );
         }
@@ -1406,7 +1874,7 @@ async function generateContextsInBatch(runtime, fullDocumentText, chunks, conten
           index: item.originalIndex
         };
       } catch (error) {
-        logger3.error(
+        logger4.error(
           `Error generating context for chunk ${item.originalIndex}: ${error.message}`,
           error.stack
         );
@@ -1427,7 +1895,7 @@ function prepareContextPrompts(chunks, fullDocumentText, contentType, batchIndic
       if (isUsingCacheCapableModel) {
         const cachingPromptInfo = contentType ? getCachingPromptForMimeType(contentType, chunkText) : getCachingContextualizationPrompt(chunkText);
         if (cachingPromptInfo.prompt.startsWith("Error:")) {
-          logger3.warn(
+          logger4.warn(
             `Skipping contextualization for chunk ${originalIndex} due to: ${cachingPromptInfo.prompt}`
           );
           return {
@@ -1449,7 +1917,7 @@ function prepareContextPrompts(chunks, fullDocumentText, contentType, batchIndic
       } else {
         const prompt = contentType ? getPromptForMimeType(contentType, fullDocumentText, chunkText) : getContextualizationPrompt(fullDocumentText, chunkText);
         if (prompt.startsWith("Error:")) {
-          logger3.warn(`Skipping contextualization for chunk ${originalIndex} due to: ${prompt}`);
+          logger4.warn(`Skipping contextualization for chunk ${originalIndex} due to: ${prompt}`);
           return {
             prompt: null,
             originalIndex,
@@ -1467,7 +1935,7 @@ function prepareContextPrompts(chunks, fullDocumentText, contentType, batchIndic
         };
       }
     } catch (error) {
-      logger3.error(
+      logger4.error(
         `Error preparing prompt for chunk ${originalIndex}: ${error.message}`,
         error.stack
       );
@@ -1488,7 +1956,7 @@ async function generateEmbeddingWithValidation(runtime, text) {
     });
     const embedding = Array.isArray(embeddingResult) ? embeddingResult : embeddingResult?.embedding;
     if (!embedding || embedding.length === 0) {
-      logger3.warn(`Zero vector detected. Embedding result: ${JSON.stringify(embedding)}`);
+      logger4.warn(`Zero vector detected. Embedding result: ${JSON.stringify(embedding)}`);
       return {
         embedding: null,
         success: false,
@@ -1506,12 +1974,12 @@ async function withRateLimitRetry(operation, errorContext, retryDelay) {
   } catch (error) {
     if (error.status === 429) {
       const delay = retryDelay || error.headers?.["retry-after"] || 5;
-      logger3.warn(`Rate limit hit for ${errorContext}. Retrying after ${delay}s`);
-      await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+      logger4.warn(`Rate limit hit for ${errorContext}. Retrying after ${delay}s`);
+      await new Promise((resolve2) => setTimeout(resolve2, delay * 1e3));
       try {
         return await operation();
       } catch (retryError) {
-        logger3.error(`Failed after retry for ${errorContext}: ${retryError.message}`);
+        logger4.error(`Failed after retry for ${errorContext}: ${retryError.message}`);
         throw retryError;
       }
     }
@@ -1546,15 +2014,15 @@ function createRateLimiter(requestsPerMinute, tokensPerMinute) {
       if (timeToWait > 0) {
         const reason = requestLimitExceeded ? "request" : "token";
         if (timeToWait > 5e3) {
-          logger3.info(
+          logger4.info(
             `[Document Processor] Rate limiting: waiting ${Math.round(timeToWait / 1e3)}s due to ${reason} limit`
           );
         } else {
-          logger3.debug(
+          logger4.debug(
             `[Document Processor] Rate limiting: ${timeToWait}ms wait (${reason} limit)`
           );
         }
-        await new Promise((resolve) => setTimeout(resolve, timeToWait));
+        await new Promise((resolve2) => setTimeout(resolve2, timeToWait));
       }
     }
     requestTimes.push(now);
@@ -1572,20 +2040,230 @@ function logKnowledgeGenerationSummary({
 }) {
   if (failedCount > 0 || process.env.NODE_ENV === "development") {
     const status = failedCount > 0 ? "PARTIAL" : "SUCCESS";
-    logger3.info(
+    logger4.info(
       `[Document Processor] ${status}: ${savedCount}/${totalChunks} chunks, CTX: ${ctxEnabled ? "ON" : "OFF"}, Provider: ${providerLimits.provider}`
     );
   }
   if (failedCount > 0) {
-    logger3.warn(`[Document Processor] ${failedCount} chunks failed processing`);
+    logger4.warn(`[Document Processor] ${failedCount} chunks failed processing`);
   }
 }
 
+// src/docs-loader.ts
+import { logger as logger5 } from "@elizaos/core";
+import * as fs from "fs";
+import * as path from "path";
+function getKnowledgePath(runtimePath) {
+  const knowledgePath = runtimePath || process.env.KNOWLEDGE_PATH || path.join(process.cwd(), "docs");
+  const resolvedPath = path.resolve(knowledgePath);
+  if (!fs.existsSync(resolvedPath)) {
+    logger5.warn(`Knowledge path does not exist: ${resolvedPath}`);
+    if (runtimePath) {
+      logger5.warn("Please create the directory or update KNOWLEDGE_PATH in agent settings");
+    } else if (process.env.KNOWLEDGE_PATH) {
+      logger5.warn("Please create the directory or update KNOWLEDGE_PATH environment variable");
+    } else {
+      logger5.info("To use the knowledge plugin, either:");
+      logger5.info('1. Create a "docs" folder in your project root');
+      logger5.info("2. Set KNOWLEDGE_PATH in agent settings or environment variable");
+    }
+  }
+  return resolvedPath;
+}
+async function loadDocsFromPath(service, agentId, worldId, knowledgePath) {
+  const docsPath = getKnowledgePath(knowledgePath);
+  if (!fs.existsSync(docsPath)) {
+    logger5.warn(`Knowledge path does not exist: ${docsPath}`);
+    return { total: 0, successful: 0, failed: 0 };
+  }
+  logger5.info(`Loading documents from: ${docsPath}`);
+  const files = getAllFiles(docsPath);
+  if (files.length === 0) {
+    logger5.info("No files found in knowledge path");
+    return { total: 0, successful: 0, failed: 0 };
+  }
+  logger5.info(`Found ${files.length} files to process`);
+  let successful = 0;
+  let failed = 0;
+  for (const filePath of files) {
+    try {
+      const fileName = path.basename(filePath);
+      const fileExt = path.extname(filePath).toLowerCase();
+      if (fileName.startsWith(".")) {
+        continue;
+      }
+      const contentType = getContentType(fileExt);
+      if (!contentType) {
+        logger5.debug(`Skipping unsupported file type: ${filePath}`);
+        continue;
+      }
+      const fileBuffer = fs.readFileSync(filePath);
+      const isBinary = isBinaryContentType(contentType, fileName);
+      const content = isBinary ? fileBuffer.toString("base64") : fileBuffer.toString("utf-8");
+      const knowledgeOptions = {
+        clientDocumentId: "",
+        // Will be generated by the service based on content
+        contentType,
+        originalFilename: fileName,
+        worldId: worldId || agentId,
+        content,
+        roomId: agentId,
+        entityId: agentId
+      };
+      logger5.debug(`Processing document: ${fileName}`);
+      const result = await service.addKnowledge(knowledgeOptions);
+      logger5.info(`\u2705 "${fileName}": ${result.fragmentCount} fragments created`);
+      successful++;
+    } catch (error) {
+      logger5.error(`Failed to process file ${filePath}:`, error);
+      failed++;
+    }
+  }
+  logger5.info(
+    `Document loading complete: ${successful} successful, ${failed} failed out of ${files.length} total`
+  );
+  return {
+    total: files.length,
+    successful,
+    failed
+  };
+}
+function getAllFiles(dirPath, files = []) {
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (!["node_modules", ".git", ".vscode", "dist", "build"].includes(entry.name)) {
+          getAllFiles(fullPath, files);
+        }
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  } catch (error) {
+    logger5.error(`Error reading directory ${dirPath}:`, error);
+  }
+  return files;
+}
+function getContentType(extension) {
+  const contentTypes = {
+    // Text documents
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".markdown": "text/markdown",
+    ".tson": "text/plain",
+    ".xml": "application/xml",
+    ".csv": "text/csv",
+    ".tsv": "text/tab-separated-values",
+    ".log": "text/plain",
+    // Web files
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".css": "text/css",
+    ".scss": "text/x-scss",
+    ".sass": "text/x-sass",
+    ".less": "text/x-less",
+    // JavaScript/TypeScript
+    ".js": "text/javascript",
+    ".jsx": "text/javascript",
+    ".ts": "text/typescript",
+    ".tsx": "text/typescript",
+    ".mjs": "text/javascript",
+    ".cjs": "text/javascript",
+    ".vue": "text/x-vue",
+    ".svelte": "text/x-svelte",
+    ".astro": "text/x-astro",
+    // Python
+    ".py": "text/x-python",
+    ".pyw": "text/x-python",
+    ".pyi": "text/x-python",
+    // Java/Kotlin/Scala
+    ".java": "text/x-java",
+    ".kt": "text/x-kotlin",
+    ".kts": "text/x-kotlin",
+    ".scala": "text/x-scala",
+    // C/C++/C#
+    ".c": "text/x-c",
+    ".cpp": "text/x-c++",
+    ".cc": "text/x-c++",
+    ".cxx": "text/x-c++",
+    ".h": "text/x-c",
+    ".hpp": "text/x-c++",
+    ".cs": "text/x-csharp",
+    // Other languages
+    ".php": "text/x-php",
+    ".rb": "text/x-ruby",
+    ".go": "text/x-go",
+    ".rs": "text/x-rust",
+    ".swift": "text/x-swift",
+    ".r": "text/x-r",
+    ".R": "text/x-r",
+    ".m": "text/x-objectivec",
+    ".mm": "text/x-objectivec",
+    ".clj": "text/x-clojure",
+    ".cljs": "text/x-clojure",
+    ".ex": "text/x-elixir",
+    ".exs": "text/x-elixir",
+    ".lua": "text/x-lua",
+    ".pl": "text/x-perl",
+    ".pm": "text/x-perl",
+    ".dart": "text/x-dart",
+    ".hs": "text/x-haskell",
+    ".elm": "text/x-elm",
+    ".ml": "text/x-ocaml",
+    ".fs": "text/x-fsharp",
+    ".fsx": "text/x-fsharp",
+    ".vb": "text/x-vb",
+    ".pas": "text/x-pascal",
+    ".d": "text/x-d",
+    ".nim": "text/x-nim",
+    ".zig": "text/x-zig",
+    ".jl": "text/x-julia",
+    ".tcl": "text/x-tcl",
+    ".awk": "text/x-awk",
+    ".sed": "text/x-sed",
+    // Shell scripts
+    ".sh": "text/x-sh",
+    ".bash": "text/x-sh",
+    ".zsh": "text/x-sh",
+    ".fish": "text/x-fish",
+    ".ps1": "text/x-powershell",
+    ".bat": "text/x-batch",
+    ".cmd": "text/x-batch",
+    // Config files
+    ".json": "application/json",
+    ".yaml": "text/x-yaml",
+    ".yml": "text/x-yaml",
+    ".toml": "text/x-toml",
+    ".ini": "text/x-ini",
+    ".cfg": "text/x-ini",
+    ".conf": "text/x-ini",
+    ".env": "text/plain",
+    ".gitignore": "text/plain",
+    ".dockerignore": "text/plain",
+    ".editorconfig": "text/plain",
+    ".properties": "text/x-properties",
+    // Database
+    ".sql": "text/x-sql",
+    // Binary documents
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  };
+  return contentTypes[extension] || null;
+}
+
 // src/service.ts
+var parseBooleanEnv2 = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toLowerCase() === "true";
+  return false;
+};
 var KnowledgeService = class _KnowledgeService extends Service {
   static serviceType = "knowledge";
-  config;
-  knowledgeConfig;
+  config = {};
+  knowledgeConfig = {};
   capabilityDescription = "Provides Retrieval Augmented Generation capabilities, including knowledge upload and querying.";
   knowledgeProcessingSemaphore;
   /**
@@ -1595,53 +2273,32 @@ var KnowledgeService = class _KnowledgeService extends Service {
   constructor(runtime, config) {
     super(runtime);
     this.knowledgeProcessingSemaphore = new Semaphore(10);
-    const parseBooleanEnv = (value) => {
-      if (typeof value === "boolean") return value;
-      if (typeof value === "string") return value.toLowerCase() === "true";
-      return false;
-    };
-    const loadDocsOnStartup = parseBooleanEnv(config?.LOAD_DOCS_ON_STARTUP) || process.env.LOAD_DOCS_ON_STARTUP === "true";
-    this.knowledgeConfig = {
-      CTX_KNOWLEDGE_ENABLED: parseBooleanEnv(config?.CTX_KNOWLEDGE_ENABLED),
-      LOAD_DOCS_ON_STARTUP: loadDocsOnStartup,
-      MAX_INPUT_TOKENS: config?.MAX_INPUT_TOKENS,
-      MAX_OUTPUT_TOKENS: config?.MAX_OUTPUT_TOKENS,
-      EMBEDDING_PROVIDER: config?.EMBEDDING_PROVIDER,
-      TEXT_PROVIDER: config?.TEXT_PROVIDER,
-      TEXT_EMBEDDING_MODEL: config?.TEXT_EMBEDDING_MODEL
-    };
-    this.config = { ...this.knowledgeConfig };
-    logger4.info(
-      `KnowledgeService initialized for agent ${this.runtime.agentId} with config:`,
-      this.knowledgeConfig
-    );
-    if (this.knowledgeConfig.LOAD_DOCS_ON_STARTUP) {
-      logger4.info("LOAD_DOCS_ON_STARTUP is enabled. Loading documents from docs folder...");
-      this.loadInitialDocuments().catch((error) => {
-        logger4.error("Error during initial document loading in KnowledgeService:", error);
-      });
-    } else {
-      logger4.info("LOAD_DOCS_ON_STARTUP is disabled. Skipping automatic document loading.");
-    }
   }
   async loadInitialDocuments() {
-    logger4.info(
+    logger6.info(
       `KnowledgeService: Checking for documents to load on startup for agent ${this.runtime.agentId}`
     );
     try {
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      const result = await loadDocsFromPath(this, this.runtime.agentId);
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+      const knowledgePath = this.runtime.getSetting("KNOWLEDGE_PATH");
+      const result = await loadDocsFromPath(
+        this,
+        this.runtime.agentId,
+        void 0,
+        // worldId
+        knowledgePath
+      );
       if (result.successful > 0) {
-        logger4.info(
+        logger6.info(
           `KnowledgeService: Loaded ${result.successful} documents from docs folder on startup for agent ${this.runtime.agentId}`
         );
       } else {
-        logger4.info(
+        logger6.info(
           `KnowledgeService: No new documents found to load on startup for agent ${this.runtime.agentId}`
         );
       }
     } catch (error) {
-      logger4.error(
+      logger6.error(
         `KnowledgeService: Error loading documents on startup for agent ${this.runtime.agentId}:`,
         error
       );
@@ -1653,23 +2310,90 @@ var KnowledgeService = class _KnowledgeService extends Service {
    * @returns Initialized Knowledge service
    */
   static async start(runtime) {
-    logger4.info(`Starting Knowledge service for agent: ${runtime.agentId}`);
+    logger6.info(`Starting Knowledge service for agent: ${runtime.agentId}`);
+    logger6.info("Initializing Knowledge Plugin...");
+    let validatedConfig = {};
+    try {
+      logger6.info("Validating model configuration for Knowledge plugin...");
+      logger6.debug(`[Knowledge Plugin] INIT DEBUG:`);
+      logger6.debug(
+        `[Knowledge Plugin] - process.env.CTX_KNOWLEDGE_ENABLED: '${process.env.CTX_KNOWLEDGE_ENABLED}'`
+      );
+      const config = {
+        CTX_KNOWLEDGE_ENABLED: parseBooleanEnv2(runtime.getSetting("CTX_KNOWLEDGE_ENABLED"))
+      };
+      logger6.debug(
+        `[Knowledge Plugin] - config.CTX_KNOWLEDGE_ENABLED: '${config.CTX_KNOWLEDGE_ENABLED}'`
+      );
+      logger6.debug(
+        `[Knowledge Plugin] - runtime.getSetting('CTX_KNOWLEDGE_ENABLED'): '${runtime.getSetting("CTX_KNOWLEDGE_ENABLED")}'`
+      );
+      validatedConfig = validateModelConfig(runtime);
+      const ctxEnabledFromEnv = parseBooleanEnv2(process.env.CTX_KNOWLEDGE_ENABLED);
+      const ctxEnabledFromRuntime = parseBooleanEnv2(runtime.getSetting("CTX_KNOWLEDGE_ENABLED"));
+      const ctxEnabledFromValidated = validatedConfig.CTX_KNOWLEDGE_ENABLED;
+      const finalCtxEnabled = ctxEnabledFromValidated;
+      logger6.debug(`[Knowledge Plugin] CTX_KNOWLEDGE_ENABLED sources:`);
+      logger6.debug(`[Knowledge Plugin] - From env: ${ctxEnabledFromEnv}`);
+      logger6.debug(`[Knowledge Plugin] - From runtime: ${ctxEnabledFromRuntime}`);
+      logger6.debug(`[Knowledge Plugin] - FINAL RESULT: ${finalCtxEnabled}`);
+      if (finalCtxEnabled) {
+        logger6.info("Running in Contextual Knowledge mode with text generation capabilities.");
+        logger6.info(
+          `Using ${validatedConfig.EMBEDDING_PROVIDER || "auto-detected"} for embeddings and ${validatedConfig.TEXT_PROVIDER} for text generation.`
+        );
+        logger6.info(`Text model: ${validatedConfig.TEXT_MODEL}`);
+      } else {
+        const usingPluginOpenAI = !process.env.EMBEDDING_PROVIDER;
+        logger6.warn(
+          "Running in Basic Embedding mode - documents will NOT be enriched with context!"
+        );
+        logger6.info("To enable contextual enrichment:");
+        logger6.info("   - Set CTX_KNOWLEDGE_ENABLED=true");
+        logger6.info("   - Configure TEXT_PROVIDER (anthropic/openai/openrouter/google)");
+        logger6.info("   - Configure TEXT_MODEL and API key");
+        if (usingPluginOpenAI) {
+          logger6.info("Using auto-detected configuration from plugin-openai for embeddings.");
+        } else {
+          logger6.info(
+            `Using ${validatedConfig.EMBEDDING_PROVIDER} for embeddings with ${validatedConfig.TEXT_EMBEDDING_MODEL}.`
+          );
+        }
+      }
+      logger6.success("Model configuration validated successfully.");
+      logger6.success(`Knowledge Plugin initialized for agent: ${runtime.character.name}`);
+      logger6.info(
+        "Knowledge Plugin initialized. Frontend panel should be discoverable via its public route."
+      );
+    } catch (error) {
+      logger6.error("Failed to initialize Knowledge plugin:", error);
+      throw error;
+    }
     const service = new _KnowledgeService(runtime);
+    service.config = validatedConfig;
+    if (service.config.LOAD_DOCS_ON_STARTUP) {
+      logger6.info("LOAD_DOCS_ON_STARTUP is enabled. Loading documents from docs folder...");
+      service.loadInitialDocuments().catch((error) => {
+        logger6.error("Error during initial document loading in KnowledgeService:", error);
+      });
+    } else {
+      logger6.info("LOAD_DOCS_ON_STARTUP is disabled. Skipping automatic document loading.");
+    }
     if (service.runtime.character?.knowledge && service.runtime.character.knowledge.length > 0) {
-      logger4.info(
+      logger6.info(
         `KnowledgeService: Processing ${service.runtime.character.knowledge.length} character knowledge items.`
       );
       const stringKnowledge = service.runtime.character.knowledge.filter(
         (item) => typeof item === "string"
       );
       await service.processCharacterKnowledge(stringKnowledge).catch((err) => {
-        logger4.error(
+        logger6.error(
           `KnowledgeService: Error processing character knowledge during startup: ${err.message}`,
           err
         );
       });
     } else {
-      logger4.info(
+      logger6.info(
         `KnowledgeService: No character knowledge to process for agent ${runtime.agentId}.`
       );
     }
@@ -1680,10 +2404,10 @@ var KnowledgeService = class _KnowledgeService extends Service {
    * @param runtime Agent runtime
    */
   static async stop(runtime) {
-    logger4.info(`Stopping Knowledge service for agent: ${runtime.agentId}`);
+    logger6.info(`Stopping Knowledge service for agent: ${runtime.agentId}`);
     const service = runtime.getService(_KnowledgeService.serviceType);
     if (!service) {
-      logger4.warn(`KnowledgeService not found for agent ${runtime.agentId} during stop.`);
+      logger6.warn(`KnowledgeService not found for agent ${runtime.agentId} during stop.`);
     }
     if (service instanceof _KnowledgeService) {
       await service.stop();
@@ -1693,7 +2417,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
    * Stop the service
    */
   async stop() {
-    logger4.info(`Knowledge service stopping for agent: ${this.runtime.agentId}`);
+    logger6.info(`Knowledge service stopping for agent: ${this.runtime.character?.name}`);
   }
   /**
    * Add knowledge to the system
@@ -1708,11 +2432,11 @@ var KnowledgeService = class _KnowledgeService extends Service {
       maxChars: 2e3
       // Use first 2KB of content for ID generation
     });
-    logger4.info(`Processing "${options.originalFilename}" (${options.contentType})`);
+    logger6.info(`Processing "${options.originalFilename}" (${options.contentType})`);
     try {
       const existingDocument = await this.runtime.getMemoryById(contentBasedId);
       if (existingDocument && existingDocument.metadata?.type === MemoryType2.DOCUMENT) {
-        logger4.info(`"${options.originalFilename}" already exists - skipping`);
+        logger6.info(`"${options.originalFilename}" already exists - skipping`);
         const fragments = await this.runtime.getMemories({
           tableName: "knowledge"
         });
@@ -1726,7 +2450,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
         };
       }
     } catch (error) {
-      logger4.debug(
+      logger6.debug(
         `Document ${contentBasedId} not found or error checking existence, proceeding with processing: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -1753,7 +2477,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
   }) {
     const agentId = passedAgentId || this.runtime.agentId;
     try {
-      logger4.debug(
+      logger6.debug(
         `KnowledgeService: Processing document ${originalFilename} (type: ${contentType}) via processDocument for agent: ${agentId}`
       );
       let fileBuffer = null;
@@ -1764,7 +2488,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
         try {
           fileBuffer = Buffer.from(content, "base64");
         } catch (e) {
-          logger4.error(
+          logger6.error(
             `KnowledgeService: Failed to convert base64 to buffer for ${originalFilename}: ${e.message}`
           );
           throw new Error(`Invalid base64 content for PDF file ${originalFilename}`);
@@ -1775,7 +2499,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
         try {
           fileBuffer = Buffer.from(content, "base64");
         } catch (e) {
-          logger4.error(
+          logger6.error(
             `KnowledgeService: Failed to convert base64 to buffer for ${originalFilename}: ${e.message}`
           );
           throw new Error(`Invalid base64 content for binary file ${originalFilename}`);
@@ -1792,11 +2516,11 @@ var KnowledgeService = class _KnowledgeService extends Service {
             if (invalidCharCount > 0 && invalidCharCount / textLength > 0.1) {
               throw new Error("Decoded content contains too many invalid characters");
             }
-            logger4.debug(`Successfully decoded base64 content for text file: ${originalFilename}`);
+            logger6.debug(`Successfully decoded base64 content for text file: ${originalFilename}`);
             extractedText = decodedText;
             documentContentToStore = decodedText;
           } catch (e) {
-            logger4.error(
+            logger6.error(
               `Failed to decode base64 for ${originalFilename}: ${e instanceof Error ? e.message : String(e)}`
             );
             throw new Error(
@@ -1804,7 +2528,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
             );
           }
         } else {
-          logger4.debug(`Treating content as plain text for file: ${originalFilename}`);
+          logger6.debug(`Treating content as plain text for file: ${originalFilename}`);
           extractedText = content;
           documentContentToStore = content;
         }
@@ -1813,7 +2537,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
         const noTextError = new Error(
           `KnowledgeService: No text content extracted from ${originalFilename} (type: ${contentType}).`
         );
-        logger4.warn(noTextError.message);
+        logger6.warn(noTextError.message);
         throw noTextError;
       }
       const documentMemory = createDocumentMemory({
@@ -1839,14 +2563,14 @@ var KnowledgeService = class _KnowledgeService extends Service {
         roomId: roomId || agentId,
         entityId: entityId || agentId
       };
-      logger4.debug(
+      logger6.debug(
         `KnowledgeService: Creating memory with agentId=${agentId}, entityId=${entityId}, roomId=${roomId}, this.runtime.agentId=${this.runtime.agentId}`
       );
-      logger4.debug(
+      logger6.debug(
         `KnowledgeService: memoryWithScope agentId=${memoryWithScope.agentId}, entityId=${memoryWithScope.entityId}`
       );
       await this.runtime.createMemory(memoryWithScope, "documents");
-      logger4.debug(
+      logger6.debug(
         `KnowledgeService: Stored document ${originalFilename} (Memory ID: ${memoryWithScope.id})`
       );
       const fragmentCount = await processFragmentsSynchronously({
@@ -1861,14 +2585,14 @@ var KnowledgeService = class _KnowledgeService extends Service {
         worldId: worldId || agentId,
         documentTitle: originalFilename
       });
-      logger4.debug(`"${originalFilename}" stored with ${fragmentCount} fragments`);
+      logger6.debug(`"${originalFilename}" stored with ${fragmentCount} fragments`);
       return {
         clientDocumentId,
         storedDocumentMemoryId: memoryWithScope.id,
         fragmentCount
       };
     } catch (error) {
-      logger4.error(
+      logger6.error(
         `KnowledgeService: Error processing document ${originalFilename}: ${error.message}`,
         error.stack
       );
@@ -1877,7 +2601,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
   }
   // --- Knowledge methods moved from AgentRuntime ---
   async handleProcessingError(error, context) {
-    logger4.error(`KnowledgeService: Error ${context}:`, error?.message || error || "Unknown error");
+    logger6.error(`KnowledgeService: Error ${context}:`, error?.message || error || "Unknown error");
     throw error;
   }
   async checkExistingKnowledge(knowledgeId) {
@@ -1885,9 +2609,9 @@ var KnowledgeService = class _KnowledgeService extends Service {
     return !!existingDocument;
   }
   async getKnowledge(message, scope) {
-    logger4.debug("KnowledgeService: getKnowledge called for message id: " + message.id);
+    logger6.debug("KnowledgeService: getKnowledge called for message id: " + message.id);
     if (!message?.content?.text || message?.content?.text.trim().length === 0) {
-      logger4.warn("KnowledgeService: Invalid or empty message content for knowledge query.");
+      logger6.warn("KnowledgeService: Invalid or empty message content for knowledge query.");
       return [];
     }
     const embedding = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, {
@@ -1926,7 +2650,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
     try {
       const existingMemory = await this.runtime.getMemoryById(memoryId);
       if (!existingMemory) {
-        logger4.warn(`Cannot enrich memory ${memoryId} - memory not found`);
+        logger6.warn(`Cannot enrich memory ${memoryId} - memory not found`);
         return;
       }
       const updatedMetadata = {
@@ -1947,11 +2671,11 @@ var KnowledgeService = class _KnowledgeService extends Service {
         id: memoryId,
         metadata: updatedMetadata
       });
-      logger4.debug(
+      logger6.debug(
         `Enriched conversation memory ${memoryId} with RAG data: ${ragMetadata.totalFragments} fragments`
       );
     } catch (error) {
-      logger4.warn(
+      logger6.warn(
         `Failed to enrich conversation memory ${memoryId} with RAG data: ${error.message}`
       );
     }
@@ -1974,7 +2698,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
       ragMetadata,
       timestamp: now
     });
-    logger4.debug(`Stored pending RAG metadata for next conversation memory`);
+    logger6.debug(`Stored pending RAG metadata for next conversation memory`);
   }
   /**
    * Try to enrich recent conversation memories with pending RAG metadata
@@ -2008,12 +2732,12 @@ var KnowledgeService = class _KnowledgeService extends Service {
         }
       }
     } catch (error) {
-      logger4.warn(`Error enriching recent memories with RAG data: ${error.message}`);
+      logger6.warn(`Error enriching recent memories with RAG data: ${error.message}`);
     }
   }
   async processCharacterKnowledge(items) {
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
-    logger4.info(
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    logger6.info(
       `KnowledgeService: Processing ${items.length} character knowledge items for agent ${this.runtime.agentId}`
     );
     const processingPromises = items.map(async (item) => {
@@ -2026,12 +2750,12 @@ var KnowledgeService = class _KnowledgeService extends Service {
           // A constant identifier for character knowledge
         });
         if (await this.checkExistingKnowledge(knowledgeId)) {
-          logger4.debug(
+          logger6.debug(
             `KnowledgeService: Character knowledge item with ID ${knowledgeId} already exists. Skipping.`
           );
           return;
         }
-        logger4.debug(
+        logger6.debug(
           `KnowledgeService: Processing character knowledge for ${this.runtime.character?.name} - ${item.slice(0, 100)}`
         );
         let metadata = {
@@ -2082,7 +2806,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
       }
     });
     await Promise.all(processingPromises);
-    logger4.info(
+    logger6.info(
       `KnowledgeService: Finished processing character knowledge for agent ${this.runtime.agentId}.`
     );
   }
@@ -2102,7 +2826,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
       worldId: scope?.worldId ?? this.runtime.agentId,
       entityId: scope?.entityId ?? this.runtime.agentId
     };
-    logger4.debug(`KnowledgeService: _internalAddKnowledge called for item ID ${item.id}`);
+    logger6.debug(`KnowledgeService: _internalAddKnowledge called for item ID ${item.id}`);
     const documentMemory = {
       id: item.id,
       // This ID should be the unique ID for the document being added.
@@ -2124,7 +2848,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
     };
     const existingDocument = await this.runtime.getMemoryById(item.id);
     if (existingDocument) {
-      logger4.debug(
+      logger6.debug(
         `KnowledgeService: Document ${item.id} already exists in _internalAddKnowledge, updating...`
       );
       await this.runtime.updateMemory({
@@ -2148,13 +2872,13 @@ var KnowledgeService = class _KnowledgeService extends Service {
         await this.processDocumentFragment(fragment);
         fragmentsProcessed++;
       } catch (error) {
-        logger4.error(
+        logger6.error(
           `KnowledgeService: Error processing fragment ${fragment.id} for document ${item.id}:`,
           error
         );
       }
     }
-    logger4.debug(
+    logger6.debug(
       `KnowledgeService: Processed ${fragmentsProcessed}/${fragments.length} fragments for document ${item.id}.`
     );
   }
@@ -2163,7 +2887,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
       await this.runtime.addEmbeddingToMemory(fragment);
       await this.runtime.createMemory(fragment, "knowledge");
     } catch (error) {
-      logger4.error(
+      logger6.error(
         `KnowledgeService: Error processing fragment ${fragment.id}:`,
         error instanceof Error ? error.message : String(error)
       );
@@ -2228,7 +2952,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
    */
   async deleteMemory(memoryId) {
     await this.runtime.deleteMemory(memoryId);
-    logger4.info(
+    logger6.info(
       `KnowledgeService: Deleted memory ${memoryId} for agent ${this.runtime.agentId}. Assumed it was a document or related fragment.`
     );
   }
@@ -2236,7 +2960,7 @@ var KnowledgeService = class _KnowledgeService extends Service {
 };
 
 // src/provider.ts
-import { addHeader, logger as logger5 } from "@elizaos/core";
+import { addHeader, logger as logger7 } from "@elizaos/core";
 var knowledgeProvider = {
   name: "KNOWLEDGE",
   description: "Knowledge from the knowledge base that the agent knows, retrieved whenever the agent needs to answer a question about their expertise.",
@@ -2274,11 +2998,11 @@ var knowledgeProvider = {
           try {
             await knowledgeService.enrichRecentMemoriesWithPendingRAG();
           } catch (error) {
-            logger5.warn("RAG memory enrichment failed:", error.message);
+            logger7.warn("RAG memory enrichment failed:", error.message);
           }
         }, 2e3);
       } catch (error) {
-        logger5.warn("RAG memory enrichment failed:", error.message);
+        logger7.warn("RAG memory enrichment failed:", error.message);
       }
     }
     return {
@@ -2305,9 +3029,9 @@ var knowledgeProvider = {
 
 // src/tests.ts
 import { MemoryType as MemoryType3, ModelType as ModelType3 } from "@elizaos/core";
-import { Buffer as Buffer2 } from "buffer";
-import * as fs from "fs";
-import * as path from "path";
+import { Buffer as Buffer3 } from "buffer";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var mockLogger = {
   info: (() => {
     const fn = (...args) => {
@@ -2704,9 +3428,9 @@ trailer
 startxref
 ${465 + content.length}
 %%EOF`;
-    return Buffer2.from(pdfContent);
+    return Buffer3.from(pdfContent);
   }
-  return Buffer2.from(content, "utf-8");
+  return Buffer3.from(content, "utf-8");
 }
 var KnowledgeTestSuite = class {
   name = "knowledge";
@@ -2719,10 +3443,10 @@ var KnowledgeTestSuite = class {
         const originalEnv = { ...process.env };
         delete process.env.KNOWLEDGE_PATH;
         try {
-          const docsPath = path.join(process.cwd(), "docs");
-          const docsExists = fs.existsSync(docsPath);
+          const docsPath = path2.join(process.cwd(), "docs");
+          const docsExists = fs2.existsSync(docsPath);
           if (!docsExists) {
-            fs.mkdirSync(docsPath, { recursive: true });
+            fs2.mkdirSync(docsPath, { recursive: true });
           }
           await index_default.init({}, runtime);
           const errorCalls = mockLogger.error.calls;
@@ -2730,7 +3454,7 @@ var KnowledgeTestSuite = class {
             throw new Error(`Unexpected error during init: ${errorCalls[0]}`);
           }
           if (!docsExists) {
-            fs.rmSync(docsPath, { recursive: true, force: true });
+            fs2.rmSync(docsPath, { recursive: true, force: true });
           }
         } finally {
           process.env = originalEnv;
@@ -2743,13 +3467,13 @@ var KnowledgeTestSuite = class {
         const originalEnv = { ...process.env };
         delete process.env.KNOWLEDGE_PATH;
         try {
-          const docsPath = path.join(process.cwd(), "docs");
-          if (fs.existsSync(docsPath)) {
-            fs.renameSync(docsPath, docsPath + ".backup");
+          const docsPath = path2.join(process.cwd(), "docs");
+          if (fs2.existsSync(docsPath)) {
+            fs2.renameSync(docsPath, docsPath + ".backup");
           }
           await index_default.init({}, runtime);
-          if (fs.existsSync(docsPath + ".backup")) {
-            fs.renameSync(docsPath + ".backup", docsPath);
+          if (fs2.existsSync(docsPath + ".backup")) {
+            fs2.renameSync(docsPath + ".backup", docsPath);
           }
         } finally {
           process.env = originalEnv;
@@ -2790,7 +3514,7 @@ var KnowledgeTestSuite = class {
     {
       name: "Should handle empty file buffer",
       fn: async (runtime) => {
-        const emptyBuffer = Buffer2.alloc(0);
+        const emptyBuffer = Buffer3.alloc(0);
         try {
           await extractTextFromDocument(emptyBuffer, "text/plain", "empty.txt");
           throw new Error("Should have thrown error for empty buffer");
@@ -2998,7 +3722,7 @@ var KnowledgeTestSuite = class {
           }
         });
         const service = await KnowledgeService.start(knowledgeRuntime);
-        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        await new Promise((resolve2) => setTimeout(resolve2, 2e3));
         const memories = await knowledgeRuntime.getMemories({
           tableName: "documents",
           entityId: knowledgeRuntime.agentId
@@ -3190,9 +3914,9 @@ var KnowledgeTestSuite = class {
 var tests_default = new KnowledgeTestSuite();
 
 // src/actions.ts
-import { logger as logger6, stringToUuid } from "@elizaos/core";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import { logger as logger8, stringToUuid } from "@elizaos/core";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var processKnowledgeAction = {
   name: "PROCESS_KNOWLEDGE",
   description: "Process and store knowledge from a file path or text content into the knowledge base",
@@ -3248,7 +3972,7 @@ var processKnowledgeAction = {
     const hasPath = pathPattern.test(text);
     const service = runtime.getService(KnowledgeService.serviceType);
     if (!service) {
-      logger6.warn("Knowledge service not available for PROCESS_KNOWLEDGE action");
+      logger8.warn("Knowledge service not available for PROCESS_KNOWLEDGE action");
       return false;
     }
     return hasKeyword || hasPath;
@@ -3265,7 +3989,7 @@ var processKnowledgeAction = {
       let response;
       if (pathMatch) {
         const filePath = pathMatch[0];
-        if (!fs2.existsSync(filePath)) {
+        if (!fs3.existsSync(filePath)) {
           response = {
             text: `I couldn't find the file at ${filePath}. Please check the path and try again.`
           };
@@ -3274,9 +3998,9 @@ var processKnowledgeAction = {
           }
           return;
         }
-        const fileBuffer = fs2.readFileSync(filePath);
-        const fileName = path2.basename(filePath);
-        const fileExt = path2.extname(filePath).toLowerCase();
+        const fileBuffer = fs3.readFileSync(filePath);
+        const fileName = path3.basename(filePath);
+        const fileExt = path3.extname(filePath).toLowerCase();
         let contentType = "text/plain";
         if (fileExt === ".pdf") contentType = "application/pdf";
         else if (fileExt === ".docx")
@@ -3326,7 +4050,7 @@ var processKnowledgeAction = {
         await callback(response);
       }
     } catch (error) {
-      logger6.error("Error in PROCESS_KNOWLEDGE action:", error);
+      logger8.error("Error in PROCESS_KNOWLEDGE action:", error);
       const errorResponse = {
         text: `I encountered an error while processing the knowledge: ${error instanceof Error ? error.message : "Unknown error"}`
       };
@@ -3417,7 +4141,7 @@ ${formattedResults}`
         await callback(response);
       }
     } catch (error) {
-      logger6.error("Error in SEARCH_KNOWLEDGE action:", error);
+      logger8.error("Error in SEARCH_KNOWLEDGE action:", error);
       const errorResponse = {
         text: `I encountered an error while searching the knowledge base: ${error instanceof Error ? error.message : "Unknown error"}`
       };
@@ -3430,9 +4154,9 @@ ${formattedResults}`
 var knowledgeActions = [processKnowledgeAction, searchKnowledgeAction];
 
 // src/routes.ts
-import { createUniqueUuid as createUniqueUuid2, logger as logger7, ModelType as ModelType4 } from "@elizaos/core";
-import fs3 from "fs";
-import path3 from "path";
+import { createUniqueUuid as createUniqueUuid2, logger as logger9, ModelType as ModelType4 } from "@elizaos/core";
+import fs4 from "fs";
+import path4 from "path";
 import multer from "multer";
 var createUploadMiddleware = (runtime) => {
   const uploadDir = runtime.getSetting("KNOWLEDGE_UPLOAD_DIR") || "/tmp/uploads/";
@@ -3477,11 +4201,11 @@ function sendError(res, status, code, message, details) {
   res.end(JSON.stringify({ success: false, error: { code, message, details } }));
 }
 var cleanupFile = (filePath) => {
-  if (filePath && fs3.existsSync(filePath)) {
+  if (filePath && fs4.existsSync(filePath)) {
     try {
-      fs3.unlinkSync(filePath);
+      fs4.unlinkSync(filePath);
     } catch (error) {
-      logger7.error(`Error cleaning up file ${filePath}:`, error);
+      logger9.error(`Error cleaning up file ${filePath}:`, error);
     }
   }
 };
@@ -3508,15 +4232,15 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const invalidFiles = files.filter((file) => {
         if (file.size === 0) {
-          logger7.warn(`File ${file.originalname} is empty`);
+          logger9.warn(`File ${file.originalname} is empty`);
           return true;
         }
         if (!file.originalname || file.originalname.trim() === "") {
-          logger7.warn(`File has no name`);
+          logger9.warn(`File has no name`);
           return true;
         }
         if (!file.path) {
-          logger7.warn(`File ${file.originalname} has no path`);
+          logger9.warn(`File ${file.originalname} has no path`);
           return true;
         }
         return false;
@@ -3533,7 +4257,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const agentId = req.body.agentId || req.query.agentId;
       if (!agentId) {
-        logger7.error("[Document Processor] \u274C No agent ID provided in upload request");
+        logger9.error("[Document Processor] \u274C No agent ID provided in upload request");
         return sendError(
           res,
           400,
@@ -3542,15 +4266,15 @@ async function uploadKnowledgeHandler(req, res, runtime) {
         );
       }
       const worldId = req.body.worldId || agentId;
-      logger7.info(`[Document Processor] \u{1F4E4} Processing file upload for agent: ${agentId}`);
+      logger9.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;
-        logger7.debug(
+        logger9.debug(
           `[Document Processor] \u{1F4C4} Processing file: ${originalFilename} (agent: ${agentId})`
         );
         try {
-          const fileBuffer = await fs3.promises.readFile(filePath);
+          const fileBuffer = await fs4.promises.readFile(filePath);
           const base64Content = fileBuffer.toString("base64");
           const addKnowledgeOpts = {
             agentId,
@@ -3581,7 +4305,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             status: "success"
           };
         } catch (fileError) {
-          logger7.error(
+          logger9.error(
             `[Document Processor] \u274C Error processing file ${file.originalname}:`,
             fileError
           );
@@ -3604,7 +4328,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const agentId = req.body.agentId || req.query.agentId;
       if (!agentId) {
-        logger7.error("[Document Processor] \u274C No agent ID provided in URL request");
+        logger9.error("[Document Processor] \u274C No agent ID provided in URL request");
         return sendError(
           res,
           400,
@@ -3612,7 +4336,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           "Agent ID is required for uploading knowledge from URLs"
         );
       }
-      logger7.info(`[Document Processor] \u{1F4E4} Processing URL upload for agent: ${agentId}`);
+      logger9.info(`[Document Processor] \u{1F4E4} Processing URL upload for agent: ${agentId}`);
       const processingPromises = fileUrls.map(async (fileUrl) => {
         try {
           const normalizedUrl = normalizeS3Url(fileUrl);
@@ -3620,7 +4344,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           const pathSegments = urlObject.pathname.split("/");
           const encodedFilename = pathSegments[pathSegments.length - 1] || "document.pdf";
           const originalFilename = decodeURIComponent(encodedFilename);
-          logger7.debug(`[Document Processor] \u{1F310} Fetching content from URL: ${fileUrl}`);
+          logger9.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") {
@@ -3660,7 +4384,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
               url: normalizedUrl
             }
           };
-          logger7.debug(
+          logger9.debug(
             `[Document Processor] \u{1F4C4} Processing knowledge from URL: ${originalFilename} (type: ${contentType})`
           );
           const result = await service.addKnowledge(addKnowledgeOpts);
@@ -3675,7 +4399,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             status: "success"
           };
         } catch (urlError) {
-          logger7.error(`[Document Processor] \u274C Error processing URL ${fileUrl}:`, urlError);
+          logger9.error(`[Document Processor] \u274C Error processing URL ${fileUrl}:`, urlError);
           return {
             fileUrl,
             status: "error_processing",
@@ -3687,7 +4411,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       sendSuccess(res, results);
     }
   } catch (error) {
-    logger7.error("[Document Processor] \u274C Error processing knowledge:", error);
+    logger9.error("[Document Processor] \u274C Error processing knowledge:", error);
     if (hasUploadedFiles) {
       cleanupFiles(req.files);
     }
@@ -3726,7 +4450,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))
       );
-      logger7.debug(
+      logger9.debug(
         `[Document Processor] \u{1F50D} Filtered documents by URLs: ${fileUrls.length} URLs, found ${filteredMemories.length} matching documents`
       );
     }
@@ -3741,12 +4465,12 @@ async function getKnowledgeDocumentsHandler(req, res, runtime) {
       totalRequested: fileUrls ? fileUrls.length : 0
     });
   } catch (error) {
-    logger7.error("[Document Processor] \u274C Error retrieving documents:", error);
+    logger9.error("[Document Processor] \u274C Error retrieving documents:", error);
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve documents", error.message);
   }
 }
 async function deleteKnowledgeDocumentHandler(req, res, runtime) {
-  logger7.debug(`[Document Processor] \u{1F5D1}\uFE0F DELETE request for document: ${req.params.knowledgeId}`);
+  logger9.debug(`[Document Processor] \u{1F5D1}\uFE0F DELETE request for document: ${req.params.knowledgeId}`);
   const service = runtime.getService(KnowledgeService.serviceType);
   if (!service) {
     return sendError(
@@ -3758,22 +4482,22 @@ async function deleteKnowledgeDocumentHandler(req, res, runtime) {
   }
   const knowledgeId = req.params.knowledgeId;
   if (!knowledgeId || knowledgeId.length < 36) {
-    logger7.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
+    logger9.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
     return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
   }
   try {
     const typedKnowledgeId = knowledgeId;
-    logger7.debug(`[Document Processor] \u{1F5D1}\uFE0F Deleting document: ${typedKnowledgeId}`);
+    logger9.debug(`[Document Processor] \u{1F5D1}\uFE0F Deleting document: ${typedKnowledgeId}`);
     await service.deleteMemory(typedKnowledgeId);
-    logger7.info(`[Document Processor] \u2705 Successfully deleted document: ${typedKnowledgeId}`);
+    logger9.info(`[Document Processor] \u2705 Successfully deleted document: ${typedKnowledgeId}`);
     sendSuccess(res, null, 204);
   } catch (error) {
-    logger7.error(`[Document Processor] \u274C Error deleting document ${knowledgeId}:`, error);
+    logger9.error(`[Document Processor] \u274C Error deleting document ${knowledgeId}:`, error);
     sendError(res, 500, "DELETE_ERROR", "Failed to delete document", error.message);
   }
 }
 async function getKnowledgeByIdHandler(req, res, runtime) {
-  logger7.debug(`[Document Processor] \u{1F50D} GET request for document: ${req.params.knowledgeId}`);
+  logger9.debug(`[Document Processor] \u{1F50D} GET request for document: ${req.params.knowledgeId}`);
   const service = runtime.getService(KnowledgeService.serviceType);
   if (!service) {
     return sendError(
@@ -3785,11 +4509,11 @@ async function getKnowledgeByIdHandler(req, res, runtime) {
   }
   const knowledgeId = req.params.knowledgeId;
   if (!knowledgeId || knowledgeId.length < 36) {
-    logger7.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
+    logger9.error(`[Document Processor] \u274C Invalid knowledge ID format: ${knowledgeId}`);
     return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
   }
   try {
-    logger7.debug(`[Document Processor] \u{1F50D} Retrieving document: ${knowledgeId}`);
+    logger9.debug(`[Document Processor] \u{1F50D} Retrieving document: ${knowledgeId}`);
     const agentId = req.query.agentId;
     const memories = await service.getMemories({
       tableName: "documents",
@@ -3806,19 +4530,19 @@ async function getKnowledgeByIdHandler(req, res, runtime) {
     };
     sendSuccess(res, { document: cleanDocument });
   } catch (error) {
-    logger7.error(`[Document Processor] \u274C Error retrieving document ${knowledgeId}:`, error);
+    logger9.error(`[Document Processor] \u274C Error retrieving document ${knowledgeId}:`, error);
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve document", error.message);
   }
 }
 async function knowledgePanelHandler(req, res, runtime) {
   const agentId = runtime.agentId;
-  logger7.debug(`[Document Processor] \u{1F310} Serving knowledge panel for agent ${agentId}`);
+  logger9.debug(`[Document Processor] \u{1F310} Serving knowledge panel for agent ${agentId}`);
   try {
-    const currentDir = path3.dirname(new URL(import.meta.url).pathname);
-    const frontendPath = path3.join(currentDir, "../dist/index.html");
-    logger7.debug(`[Document Processor] \u{1F310} Looking for frontend at: ${frontendPath}`);
-    if (fs3.existsSync(frontendPath)) {
-      const html = await fs3.promises.readFile(frontendPath, "utf8");
+    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}`);
+    if (fs4.existsSync(frontendPath)) {
+      const html = await fs4.promises.readFile(frontendPath, "utf8");
       const injectedHtml = html.replace(
         "<head>",
         `<head>
@@ -3834,10 +4558,10 @@ async function knowledgePanelHandler(req, res, runtime) {
     } else {
       let cssFile = "index.css";
       let jsFile = "index.js";
-      const manifestPath = path3.join(currentDir, "../dist/manifest.json");
-      if (fs3.existsSync(manifestPath)) {
+      const manifestPath = path4.join(currentDir, "../dist/manifest.json");
+      if (fs4.existsSync(manifestPath)) {
         try {
-          const manifestContent = await fs3.promises.readFile(manifestPath, "utf8");
+          const manifestContent = await fs4.promises.readFile(manifestPath, "utf8");
           const manifest = JSON.parse(manifestContent);
           for (const [key, value] of Object.entries(manifest)) {
             if (typeof value === "object" && value !== null) {
@@ -3850,10 +4574,10 @@ async function knowledgePanelHandler(req, res, runtime) {
             }
           }
         } catch (manifestError) {
-          logger7.error("[Document Processor] \u274C Error reading manifest:", manifestError);
+          logger9.error("[Document Processor] \u274C Error reading manifest:", manifestError);
         }
       }
-      logger7.debug(`[Document Processor] \u{1F310} Using fallback with CSS: ${cssFile}, JS: ${jsFile}`);
+      logger9.debug(`[Document Processor] \u{1F310} Using fallback with CSS: ${cssFile}, JS: ${jsFile}`);
       const html = `
 <!DOCTYPE html>
 <html lang="en">
@@ -3887,14 +4611,14 @@ async function knowledgePanelHandler(req, res, runtime) {
       res.end(html);
     }
   } catch (error) {
-    logger7.error("[Document Processor] \u274C Error serving frontend:", error);
+    logger9.error("[Document Processor] \u274C Error serving frontend:", error);
     sendError(res, 500, "FRONTEND_ERROR", "Failed to load knowledge panel", error.message);
   }
 }
 async function frontendAssetHandler(req, res, runtime) {
   try {
-    logger7.debug(`[Document Processor] \u{1F310} Asset request: ${req.path}`);
-    const currentDir = path3.dirname(new URL(import.meta.url).pathname);
+    logger9.debug(`[Document Processor] \u{1F310} Asset request: ${req.path}`);
+    const currentDir = path4.dirname(new URL(import.meta.url).pathname);
     const assetRequestPath = req.path;
     const assetsMarker = "/assets/";
     const assetsStartIndex = assetRequestPath.indexOf(assetsMarker);
@@ -3910,10 +4634,10 @@ async function frontendAssetHandler(req, res, runtime) {
         `Invalid asset name: '${assetName}' from path ${assetRequestPath}`
       );
     }
-    const assetPath = path3.join(currentDir, "../dist/assets", assetName);
-    logger7.debug(`[Document Processor] \u{1F310} Serving asset: ${assetPath}`);
-    if (fs3.existsSync(assetPath)) {
-      const fileStream = fs3.createReadStream(assetPath);
+    const assetPath = path4.join(currentDir, "../dist/assets", assetName);
+    logger9.debug(`[Document Processor] \u{1F310} Serving asset: ${assetPath}`);
+    if (fs4.existsSync(assetPath)) {
+      const fileStream = fs4.createReadStream(assetPath);
       let contentType = "application/octet-stream";
       if (assetPath.endsWith(".js")) {
         contentType = "application/javascript";
@@ -3926,7 +4650,7 @@ async function frontendAssetHandler(req, res, runtime) {
       sendError(res, 404, "NOT_FOUND", `Asset not found: ${req.url}`);
     }
   } catch (error) {
-    logger7.error(`[Document Processor] \u274C Error serving asset ${req.url}:`, error);
+    logger9.error(`[Document Processor] \u274C Error serving asset ${req.url}:`, error);
     sendError(res, 500, "ASSET_ERROR", `Failed to load asset ${req.url}`, error.message);
   }
 }
@@ -3987,7 +4711,7 @@ async function getKnowledgeChunksHandler(req, res, runtime) {
       }
     });
   } catch (error) {
-    logger7.error("[Document Processor] \u274C Error retrieving chunks:", error);
+    logger9.error("[Document Processor] \u274C Error retrieving chunks:", error);
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve knowledge chunks", error.message);
   }
 }
@@ -4009,14 +4733,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)) {
-      logger7.debug(
+      logger9.debug(
         `[Document Processor] \u{1F50D} Threshold value ${parsedThreshold} was clamped to ${matchThreshold}`
       );
     }
     if (req.query.limit && (parsedLimit < 1 || parsedLimit > 100)) {
-      logger7.debug(`[Document Processor] \u{1F50D} Limit value ${parsedLimit} was clamped to ${limit}`);
+      logger9.debug(`[Document Processor] \u{1F50D} Limit value ${parsedLimit} was clamped to ${limit}`);
     }
-    logger7.debug(
+    logger9.debug(
       `[Document Processor] \u{1F50D} Searching: "${searchText}" (threshold: ${matchThreshold}, limit: ${limit})`
     );
     const embedding = await runtime.useModel(ModelType4.TEXT_EMBEDDING, {
@@ -4043,7 +4767,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
               documentFilename = document.metadata.filename || documentFilename;
             }
           } catch (e) {
-            logger7.debug(`Could not fetch document ${documentId} for fragment`);
+            logger9.debug(`Could not fetch document ${documentId} for fragment`);
           }
         }
         return {
@@ -4058,7 +4782,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
         };
       })
     );
-    logger7.info(
+    logger9.info(
       `[Document Processor] \u{1F50D} Found ${enhancedResults.length} results for: "${searchText}"`
     );
     sendSuccess(res, {
@@ -4068,7 +4792,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
       count: enhancedResults.length
     });
   } catch (error) {
-    logger7.error("[Document Processor] \u274C Error searching knowledge:", error);
+    logger9.error("[Document Processor] \u274C Error searching knowledge:", error);
     sendError(res, 500, "SEARCH_ERROR", "Failed to search knowledge", error.message);
   }
 }
@@ -4080,7 +4804,7 @@ async function uploadKnowledgeWithMulter(req, res, runtime) {
   );
   uploadArray(req, res, (err) => {
     if (err) {
-      logger7.error("[Document Processor] \u274C File upload error:", err);
+      logger9.error("[Document Processor] \u274C File upload error:", err);
       return sendError(res, 400, "UPLOAD_ERROR", err.message);
     }
     uploadKnowledgeHandler(req, res, runtime);
@@ -4135,97 +4859,6 @@ var knowledgeRoutes = [
 var knowledgePlugin = {
   name: "knowledge",
   description: "Plugin for Retrieval Augmented Generation, including knowledge management and embedding.",
-  config: {
-    // Token limits - these will be read from runtime settings during init
-    MAX_INPUT_TOKENS: "4000",
-    MAX_OUTPUT_TOKENS: "4096",
-    // Contextual Knowledge settings
-    CTX_KNOWLEDGE_ENABLED: "false"
-  },
-  async init(config, runtime) {
-    logger8.info("Initializing Knowledge Plugin...");
-    try {
-      logger8.info("Validating model configuration for Knowledge plugin...");
-      logger8.info(`[Knowledge Plugin] INIT DEBUG:`);
-      logger8.info(`[Knowledge Plugin] - Runtime available: ${!!runtime}`);
-      logger8.info(
-        `[Knowledge Plugin] - process.env.CTX_KNOWLEDGE_ENABLED: '${process.env.CTX_KNOWLEDGE_ENABLED}'`
-      );
-      logger8.info(
-        `[Knowledge Plugin] - config.CTX_KNOWLEDGE_ENABLED: '${config.CTX_KNOWLEDGE_ENABLED}'`
-      );
-      if (runtime) {
-        logger8.info(
-          `[Knowledge Plugin] - runtime.getSetting('CTX_KNOWLEDGE_ENABLED'): '${runtime.getSetting("CTX_KNOWLEDGE_ENABLED")}'`
-        );
-      }
-      const validatedConfig = validateModelConfig(runtime);
-      const ctxEnabledFromEnv = process.env.CTX_KNOWLEDGE_ENABLED === "true" || process.env.CTX_KNOWLEDGE_ENABLED === "True";
-      const ctxEnabledFromConfig = config.CTX_KNOWLEDGE_ENABLED === "true" || config.CTX_KNOWLEDGE_ENABLED === "True";
-      const ctxEnabledFromValidated = validatedConfig.CTX_KNOWLEDGE_ENABLED;
-      const ctxEnabledFromRuntime = runtime ? runtime.getSetting("CTX_KNOWLEDGE_ENABLED") === "true" || runtime.getSetting("CTX_KNOWLEDGE_ENABLED") === "True" : false;
-      const finalCtxEnabled = ctxEnabledFromEnv || ctxEnabledFromConfig || ctxEnabledFromValidated || ctxEnabledFromRuntime;
-      logger8.info(`[Knowledge Plugin] CTX_KNOWLEDGE_ENABLED sources:`);
-      logger8.info(`[Knowledge Plugin] - From env: ${ctxEnabledFromEnv}`);
-      logger8.info(`[Knowledge Plugin] - From config: ${ctxEnabledFromConfig}`);
-      logger8.info(`[Knowledge Plugin] - From validated: ${ctxEnabledFromValidated}`);
-      logger8.info(`[Knowledge Plugin] - From runtime: ${ctxEnabledFromRuntime}`);
-      logger8.info(`[Knowledge Plugin] - FINAL RESULT: ${finalCtxEnabled}`);
-      if (finalCtxEnabled) {
-        logger8.info("Running in Contextual Knowledge mode with text generation capabilities.");
-        logger8.info(
-          `Using ${validatedConfig.EMBEDDING_PROVIDER || "auto-detected"} for embeddings and ${validatedConfig.TEXT_PROVIDER || process.env.TEXT_PROVIDER} for text generation.`
-        );
-        logger8.info(`Text model: ${validatedConfig.TEXT_MODEL || process.env.TEXT_MODEL}`);
-      } else {
-        const usingPluginOpenAI = !process.env.EMBEDDING_PROVIDER;
-        logger8.warn(
-          "Running in Basic Embedding mode - documents will NOT be enriched with context!"
-        );
-        logger8.info("To enable contextual enrichment:");
-        logger8.info("   - Set CTX_KNOWLEDGE_ENABLED=true");
-        logger8.info("   - Configure TEXT_PROVIDER (anthropic/openai/openrouter/google)");
-        logger8.info("   - Configure TEXT_MODEL and API key");
-        if (usingPluginOpenAI) {
-          logger8.info("Using auto-detected configuration from plugin-openai for embeddings.");
-        } else {
-          logger8.info(
-            `Using ${validatedConfig.EMBEDDING_PROVIDER} for embeddings with ${validatedConfig.TEXT_EMBEDDING_MODEL}.`
-          );
-        }
-      }
-      logger8.info("Model configuration validated successfully.");
-      if (runtime) {
-        logger8.info(`Knowledge Plugin initialized for agent: ${runtime.agentId}`);
-        const loadDocsOnStartup = config.LOAD_DOCS_ON_STARTUP === "true" || process.env.LOAD_DOCS_ON_STARTUP === "true";
-        if (loadDocsOnStartup) {
-          logger8.info("LOAD_DOCS_ON_STARTUP is enabled. Scheduling document loading...");
-          setTimeout(async () => {
-            try {
-              const service = runtime.getService(KnowledgeService.serviceType);
-              if (service instanceof KnowledgeService) {
-                const { loadDocsFromPath: loadDocsFromPath2 } = await import("./docs-loader-5H4HRYEE.js");
-                const result = await loadDocsFromPath2(service, runtime.agentId);
-                if (result.successful > 0) {
-                  logger8.info(`Loaded ${result.successful} documents from docs folder on startup`);
-                }
-              }
-            } catch (error) {
-              logger8.error("Error loading documents on startup:", error);
-            }
-          }, 5e3);
-        } else {
-          logger8.info("LOAD_DOCS_ON_STARTUP is not enabled. Skipping automatic document loading.");
-        }
-      }
-      logger8.info(
-        "Knowledge Plugin initialized. Frontend panel should be discoverable via its public route."
-      );
-    } catch (error) {
-      logger8.error("Failed to initialize Knowledge plugin:", error);
-      throw error;
-    }
-  },
   services: [KnowledgeService],
   providers: [knowledgeProvider],
   routes: knowledgeRoutes,