@elizaos/plugin-knowledge 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/cjs/index.node.cjs

@@ -63,6 +63,7 @@ var __export = (target, all) => {
 // index.node.ts
 var exports_index_node = {};
 __export(exports_index_node, {
+  knowledgeRoutes: () => knowledgeRoutes,
   knowledgeProvider: () => knowledgeProvider,
   knowledgePluginHeadless: () => knowledgePluginHeadless,
   knowledgePluginCore: () => knowledgePluginCore,
@@ -71,2869 +72,61 @@ __export(exports_index_node, {
   createKnowledgePlugin: () => createKnowledgePlugin,
   ModelConfigSchema: () => ModelConfigSchema,
   KnowledgeServiceType: () => KnowledgeServiceType,
-  KnowledgeService: () => KnowledgeService
+  KnowledgeService: () => import_core5.KnowledgeService
 });
 module.exports = __toCommonJS(exports_index_node);
 
-// actions.ts
-var fs2 = __toESM(require("node:fs"));
-var path2 = __toESM(require("node:path"));
-var import_core5 = require("@elizaos/core");
-
-// service.ts
+// index.ts
 var import_core4 = require("@elizaos/core");
 
-// config.ts
-var import_zod2 = __toESM(require("zod"));
-
-// types.ts
-var import_zod = __toESM(require("zod"));
-var ModelConfigSchema = import_zod.default.object({
-  EMBEDDING_PROVIDER: import_zod.default.enum(["openai", "google"]).optional(),
-  TEXT_PROVIDER: import_zod.default.enum(["openai", "anthropic", "openrouter", "google"]).optional(),
-  OPENAI_API_KEY: import_zod.default.string().optional(),
-  ANTHROPIC_API_KEY: import_zod.default.string().optional(),
-  OPENROUTER_API_KEY: import_zod.default.string().optional(),
-  GOOGLE_API_KEY: import_zod.default.string().optional(),
-  OPENAI_BASE_URL: import_zod.default.string().optional(),
-  ANTHROPIC_BASE_URL: import_zod.default.string().optional(),
-  OPENROUTER_BASE_URL: import_zod.default.string().optional(),
-  GOOGLE_BASE_URL: import_zod.default.string().optional(),
-  TEXT_EMBEDDING_MODEL: import_zod.default.string(),
-  TEXT_MODEL: import_zod.default.string().optional(),
-  MAX_INPUT_TOKENS: import_zod.default.string().or(import_zod.default.number()).transform((val) => typeof val === "string" ? parseInt(val, 10) : val),
-  MAX_OUTPUT_TOKENS: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 4096),
-  EMBEDDING_DIMENSION: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 1536),
-  LOAD_DOCS_ON_STARTUP: import_zod.default.boolean().default(false),
-  CTX_KNOWLEDGE_ENABLED: import_zod.default.boolean().default(false),
-  RATE_LIMIT_ENABLED: import_zod.default.boolean().default(true),
-  MAX_CONCURRENT_REQUESTS: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 150),
-  REQUESTS_PER_MINUTE: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 300),
-  TOKENS_PER_MINUTE: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 750000),
-  BATCH_DELAY_MS: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 100)
-});
-var KnowledgeServiceType = {
-  KNOWLEDGE: "knowledge"
-};
-
-// config.ts
-var parseBooleanEnv = (value) => {
-  if (typeof value === "boolean")
-    return value;
-  if (typeof value === "number")
-    return value !== 0;
-  if (typeof value === "string")
-    return value.toLowerCase() === "true";
-  return false;
-};
-function validateModelConfig(runtime) {
-  try {
-    const getSetting = (key, defaultValue) => {
-      if (runtime) {
-        return runtime.getSetting(key) || process.env[key] || defaultValue;
-      }
-      return process.env[key] || defaultValue;
-    };
-    const ctxKnowledgeEnabled = parseBooleanEnv(getSetting("CTX_KNOWLEDGE_ENABLED", "false"));
-    const embeddingProvider = getSetting("EMBEDDING_PROVIDER");
-    const assumePluginOpenAI = !embeddingProvider;
-    const textEmbeddingModel = getSetting("TEXT_EMBEDDING_MODEL") || getSetting("OPENAI_EMBEDDING_MODEL") || "text-embedding-3-small";
-    const embeddingDimension = getSetting("EMBEDDING_DIMENSION") || getSetting("OPENAI_EMBEDDING_DIMENSIONS") || "1536";
-    const openaiApiKey = getSetting("OPENAI_API_KEY");
-    const config = ModelConfigSchema.parse({
-      EMBEDDING_PROVIDER: embeddingProvider,
-      TEXT_PROVIDER: getSetting("TEXT_PROVIDER"),
-      OPENAI_API_KEY: openaiApiKey,
-      ANTHROPIC_API_KEY: getSetting("ANTHROPIC_API_KEY"),
-      OPENROUTER_API_KEY: getSetting("OPENROUTER_API_KEY"),
-      GOOGLE_API_KEY: getSetting("GOOGLE_API_KEY"),
-      OPENAI_BASE_URL: getSetting("OPENAI_BASE_URL"),
-      ANTHROPIC_BASE_URL: getSetting("ANTHROPIC_BASE_URL"),
-      OPENROUTER_BASE_URL: getSetting("OPENROUTER_BASE_URL"),
-      GOOGLE_BASE_URL: getSetting("GOOGLE_BASE_URL"),
-      TEXT_EMBEDDING_MODEL: textEmbeddingModel,
-      TEXT_MODEL: getSetting("TEXT_MODEL"),
-      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,
-      RATE_LIMIT_ENABLED: parseBooleanEnv(getSetting("RATE_LIMIT_ENABLED", "true")),
-      MAX_CONCURRENT_REQUESTS: getSetting("MAX_CONCURRENT_REQUESTS", "100"),
-      REQUESTS_PER_MINUTE: getSetting("REQUESTS_PER_MINUTE", "500"),
-      TOKENS_PER_MINUTE: getSetting("TOKENS_PER_MINUTE", "1000000"),
-      BATCH_DELAY_MS: getSetting("BATCH_DELAY_MS", "100")
-    });
-    validateConfigRequirements(config, assumePluginOpenAI);
-    return config;
-  } catch (error) {
-    if (error instanceof import_zod2.default.ZodError) {
-      const issues = error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-      throw new Error(`Model configuration validation failed: ${issues}`);
-    }
-    throw error;
-  }
-}
-function validateConfigRequirements(config, assumePluginOpenAI) {
-  const embeddingProvider = config.EMBEDDING_PROVIDER;
-  if (embeddingProvider === "openai" && !config.OPENAI_API_KEY) {
-    throw new Error('OPENAI_API_KEY is required when EMBEDDING_PROVIDER is set to "openai"');
-  }
-  if (embeddingProvider === "google" && !config.GOOGLE_API_KEY) {
-    throw new Error('GOOGLE_API_KEY is required when EMBEDDING_PROVIDER is set to "google"');
-  }
-  if (assumePluginOpenAI && config.OPENAI_API_KEY && !config.TEXT_EMBEDDING_MODEL) {
-    throw new Error("OPENAI_EMBEDDING_MODEL is required when using plugin-openai configuration");
-  }
-  if (config.CTX_KNOWLEDGE_ENABLED) {
-    if (config.TEXT_PROVIDER === "openai" && !config.OPENAI_API_KEY) {
-      throw new Error('OPENAI_API_KEY is required when TEXT_PROVIDER is set to "openai"');
-    }
-    if (config.TEXT_PROVIDER === "anthropic" && !config.ANTHROPIC_API_KEY) {
-      throw new Error('ANTHROPIC_API_KEY is required when TEXT_PROVIDER is set to "anthropic"');
-    }
-    if (config.TEXT_PROVIDER === "openrouter" && !config.OPENROUTER_API_KEY) {
-      throw new Error('OPENROUTER_API_KEY is required when TEXT_PROVIDER is set to "openrouter"');
-    }
-    if (config.TEXT_PROVIDER === "google" && !config.GOOGLE_API_KEY) {
-      throw new Error('GOOGLE_API_KEY is required when TEXT_PROVIDER is set to "google"');
-    }
-  }
-}
-async function getProviderRateLimits(runtime) {
-  const config = validateModelConfig(runtime);
-  const rateLimitEnabled = config.RATE_LIMIT_ENABLED;
-  const maxConcurrentRequests = config.MAX_CONCURRENT_REQUESTS;
-  const requestsPerMinute = config.REQUESTS_PER_MINUTE;
-  const tokensPerMinute = config.TOKENS_PER_MINUTE;
-  const batchDelayMs = config.BATCH_DELAY_MS;
-  const primaryProvider = config.TEXT_PROVIDER || config.EMBEDDING_PROVIDER;
-  if (!rateLimitEnabled) {
-    return {
-      maxConcurrentRequests,
-      requestsPerMinute: Number.MAX_SAFE_INTEGER,
-      tokensPerMinute: Number.MAX_SAFE_INTEGER,
-      provider: primaryProvider || "unlimited",
-      rateLimitEnabled: false,
-      batchDelayMs
-    };
-  }
-  return {
-    maxConcurrentRequests,
-    requestsPerMinute,
-    tokensPerMinute,
-    provider: primaryProvider || "unlimited",
-    rateLimitEnabled: true,
-    batchDelayMs
-  };
-}
-
-// docs-loader.ts
-var fs = __toESM(require("node:fs"));
-var path = __toESM(require("node:path"));
+// routes.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
 var import_core = require("@elizaos/core");
-
-// utils.ts
-var import_node_buffer = require("node:buffer");
-var import_node_crypto4 = require("node:crypto");
-var mammoth = __toESM(require("mammoth"));
-var import_unpdf = require("unpdf");
-// node_modules/uuid/dist-node/native.js
-var import_node_crypto = require("node:crypto");
-var native_default = { randomUUID: import_node_crypto.randomUUID };
-
-// node_modules/uuid/dist-node/rng.js
-var import_node_crypto2 = require("node:crypto");
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    import_node_crypto2.randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// node_modules/uuid/dist-node/regex.js
-var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
-
-// node_modules/uuid/dist-node/validate.js
-function validate(uuid) {
-  return typeof uuid === "string" && regex_default.test(uuid);
-}
-var validate_default = validate;
-
-// node_modules/uuid/dist-node/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-node/v4.js
-function _v4(options, buf, offset) {
-  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);
-}
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
-var v4_default = v4;
-// node_modules/uuid/dist-node/sha1.js
-var import_node_crypto3 = require("node:crypto");
-function sha1(bytes) {
-  if (Array.isArray(bytes)) {
-    bytes = Buffer.from(bytes);
-  } else if (typeof bytes === "string") {
-    bytes = Buffer.from(bytes, "utf8");
-  }
-  return import_node_crypto3.createHash("sha1").update(bytes).digest();
-}
-var sha1_default = sha1;
-
-// node_modules/uuid/dist-node/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-node/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-node/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;
-// utils.ts
-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();
-  if (lowerContentType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
-    try {
-      const result = await mammoth.extractRawText({ buffer: fileBuffer });
-      return result.value;
-    } catch (docxError) {
-      const errorMessage = docxError instanceof Error ? docxError.message : String(docxError);
-      throw new Error(`Failed to parse DOCX file ${originalFilename}: ${errorMessage}`);
-    }
-  } else if (lowerContentType === "application/msword" || originalFilename.toLowerCase().endsWith(".doc")) {
-    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)) {
-    return fileBuffer.toString("utf-8");
-  } else {
-    if (fileBuffer.length > MAX_FALLBACK_SIZE_BYTES) {
-      throw new Error(`File ${originalFilename} exceeds maximum size for fallback (${MAX_FALLBACK_SIZE_BYTES} bytes)`);
-    }
-    const initialBytes = fileBuffer.subarray(0, Math.min(fileBuffer.length, BINARY_CHECK_BYTES));
-    if (initialBytes.includes(0)) {
-      throw new Error(`File ${originalFilename} appears to be binary based on initial byte check`);
-    }
-    try {
-      const textContent = fileBuffer.toString("utf-8");
-      if (textContent.includes("�")) {
-        throw new Error(`File ${originalFilename} seems to be binary or has encoding issues (detected �)`);
-      }
-      return textContent;
-    } catch (_fallbackError) {
-      throw new Error(`Unsupported content type: ${contentType} for ${originalFilename}. Fallback to plain text failed`);
-    }
-  }
-}
-async function convertPdfToTextFromBuffer(pdfBuffer, _filename) {
-  try {
-    const uint8Array = new Uint8Array(pdfBuffer.buffer.slice(pdfBuffer.byteOffset, pdfBuffer.byteOffset + pdfBuffer.byteLength));
-    const result = await import_unpdf.extractText(uint8Array, {
-      mergePages: true
-    });
-    if (!result.text || result.text.trim().length === 0) {
-      return "";
-    }
-    const cleanedText = result.text.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0).join(`
-`).replace(/\n{3,}/g, `
-
-`);
-    return cleanedText;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to convert PDF to text: ${errorMessage}`);
-  }
-}
-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 normalizeS3Url(url) {
-  try {
-    const urlObj = new URL(url);
-    return `${urlObj.origin}${urlObj.pathname}`;
-  } catch {
-    return url;
-  }
-}
-async function fetchUrlContent(url) {
-  try {
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), 30000);
-    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";
-    const arrayBuffer = await response.arrayBuffer();
-    const buffer = import_node_buffer.Buffer.from(arrayBuffer);
-    const base64Content = buffer.toString("base64");
-    return {
-      content: base64Content,
-      contentType
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to fetch content from URL: ${errorMessage}`);
-  }
-}
-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 = 2000, includeFilename, contentType } = options || {};
-  let contentForHashing;
-  if (looksLikeBase64(content)) {
-    try {
-      const decoded = import_node_buffer.Buffer.from(content, "base64").toString("utf8");
-      if (!decoded.includes("�") || 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, `
-`).replace(/\r/g, `
-`).trim();
-  const componentsToHash = [agentId, contentForHashing, includeFilename || ""].filter(Boolean).join("::");
-  const hash = import_node_crypto4.createHash("sha256").update(componentsToHash).digest("hex");
-  const DOCUMENT_NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-  return v5_default(hash, DOCUMENT_NAMESPACE);
-}
-
-// docs-loader.ts
-function getKnowledgePath(runtimePath) {
-  const knowledgePath = runtimePath || process.env.KNOWLEDGE_PATH || path.join(process.cwd(), "docs");
-  const resolvedPath = path.resolve(knowledgePath);
-  if (!fs.existsSync(resolvedPath)) {
-    import_core.logger.warn(`Knowledge path does not exist: ${resolvedPath}`);
-    if (runtimePath) {
-      import_core.logger.warn("Please create the directory or update KNOWLEDGE_PATH in agent settings");
-    } else if (process.env.KNOWLEDGE_PATH) {
-      import_core.logger.warn("Please create the directory or update KNOWLEDGE_PATH environment variable");
-    } else {
-      import_core.logger.info("To use the knowledge plugin, either:");
-      import_core.logger.info('1. Create a "docs" folder in your project root');
-      import_core.logger.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)) {
-    import_core.logger.warn(`Knowledge path does not exist: ${docsPath}`);
-    return { total: 0, successful: 0, failed: 0 };
-  }
-  import_core.logger.info(`Loading documents from: ${docsPath}`);
-  const files = getAllFiles(docsPath);
-  if (files.length === 0) {
-    import_core.logger.info("No files found in knowledge path");
-    return { total: 0, successful: 0, failed: 0 };
-  }
-  import_core.logger.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) {
-        import_core.logger.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: "",
-        contentType,
-        originalFilename: fileName,
-        worldId: worldId || agentId,
-        content,
-        roomId: agentId,
-        entityId: agentId
-      };
-      import_core.logger.debug(`Processing document: ${fileName}`);
-      const result = await service.addKnowledge(knowledgeOptions);
-      import_core.logger.info(`✅ "${fileName}": ${result.fragmentCount} fragments created`);
-      successful++;
-    } catch (error) {
-      import_core.logger.error({ error }, `Failed to process file ${filePath}`);
-      failed++;
-    }
-  }
-  import_core.logger.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) {
-    import_core.logger.error({ error }, `Error reading directory ${dirPath}`);
-  }
-  return files;
-}
-function getContentType(extension) {
-  const contentTypes = {
-    ".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",
-    ".html": "text/html",
-    ".htm": "text/html",
-    ".css": "text/css",
-    ".scss": "text/x-scss",
-    ".sass": "text/x-sass",
-    ".less": "text/x-less",
-    ".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",
-    ".py": "text/x-python",
-    ".pyw": "text/x-python",
-    ".pyi": "text/x-python",
-    ".java": "text/x-java",
-    ".kt": "text/x-kotlin",
-    ".kts": "text/x-kotlin",
-    ".scala": "text/x-scala",
-    ".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",
-    ".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",
-    ".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",
-    ".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",
-    ".sql": "text/x-sql",
-    ".pdf": "application/pdf",
-    ".doc": "application/msword",
-    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-  };
-  return contentTypes[extension] || null;
-}
-
-// document-processor.ts
-var import_core3 = require("@elizaos/core");
-
-// ctx-embeddings.ts
-var DEFAULT_CHUNK_TOKEN_SIZE = 500;
-var DEFAULT_CHUNK_OVERLAP_TOKENS = 100;
-var DEFAULT_CHARS_PER_TOKEN = 3.5;
-var CONTEXT_TARGETS = {
-  DEFAULT: {
-    MIN_TOKENS: 60,
-    MAX_TOKENS: 120
-  },
-  PDF: {
-    MIN_TOKENS: 80,
-    MAX_TOKENS: 150
-  },
-  MATH_PDF: {
-    MIN_TOKENS: 100,
-    MAX_TOKENS: 180
-  },
-  CODE: {
-    MIN_TOKENS: 100,
-    MAX_TOKENS: 200
-  },
-  TECHNICAL: {
-    MIN_TOKENS: 80,
-    MAX_TOKENS: 160
-  }
-};
-var SYSTEM_PROMPTS = {
-  DEFAULT: "You are a precision text augmentation tool. Your task is to expand a given text chunk with its direct context from a larger document. You must: 1) Keep the original chunk intact; 2) Add critical context from surrounding text; 3) Never summarize or rephrase the original chunk; 4) Create contextually rich output for improved semantic retrieval.",
-  CODE: "You are a precision code augmentation tool. Your task is to expand a given code chunk with necessary context from the larger codebase. You must: 1) Keep the original code chunk intact with exact syntax and indentation; 2) Add relevant imports, function signatures, or class definitions; 3) Include critical surrounding code context; 4) Create contextually rich output that maintains correct syntax.",
-  PDF: "You are a precision document augmentation tool. Your task is to expand a given PDF text chunk with its direct context from the larger document. You must: 1) Keep the original chunk intact; 2) Add section headings, references, or figure captions; 3) Include text that immediately precedes and follows the chunk; 4) Create contextually rich output that maintains the document's original structure.",
-  MATH_PDF: "You are a precision mathematical content augmentation tool. Your task is to expand a given mathematical text chunk with essential context. You must: 1) Keep original mathematical notations and expressions exactly as they appear; 2) Add relevant definitions, theorems, or equations from elsewhere in the document; 3) Preserve all LaTeX or mathematical formatting; 4) Create contextually rich output for improved mathematical comprehension.",
-  TECHNICAL: "You are a precision technical documentation augmentation tool. Your task is to expand a technical document chunk with critical context. You must: 1) Keep the original chunk intact including all technical terminology; 2) Add relevant configuration examples, parameter definitions, or API references; 3) Include any prerequisite information; 4) Create contextually rich output that maintains technical accuracy."
-};
-var CONTEXTUAL_CHUNK_ENRICHMENT_PROMPT_TEMPLATE = `
-<document>
-{doc_content}
-</document>
-
-Here is the chunk we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this chunk by adding critical surrounding context. Follow these guidelines:
-
-1. Identify the document's main topic and key information relevant to understanding this chunk
-2. Include 2-3 sentences before the chunk that provide essential context
-3. Include 2-3 sentences after the chunk that complete thoughts or provide resolution
-4. For technical documents, include any definitions or explanations of terms used in the chunk
-5. For narrative content, include character or setting information needed to understand the chunk
-6. Keep the original chunk text COMPLETELY INTACT and UNCHANGED in your response
-7. Do not use phrases like "this chunk discusses" - directly present the context
-8. The total length should be between {min_tokens} and {max_tokens} tokens
-9. Format the response as a single coherent paragraph
-
-Provide ONLY the enriched chunk text in your response:`;
-var CACHED_CHUNK_PROMPT_TEMPLATE = `
-Here is the chunk we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this chunk by adding critical surrounding context. Follow these guidelines:
-
-1. Identify the document's main topic and key information relevant to understanding this chunk
-2. Include 2-3 sentences before the chunk that provide essential context
-3. Include 2-3 sentences after the chunk that complete thoughts or provide resolution
-4. For technical documents, include any definitions or explanations of terms used in the chunk
-5. For narrative content, include character or setting information needed to understand the chunk
-6. Keep the original chunk text COMPLETELY INTACT and UNCHANGED in your response
-7. Do not use phrases like "this chunk discusses" - directly present the context
-8. The total length should be between {min_tokens} and {max_tokens} tokens
-9. Format the response as a single coherent paragraph
-
-Provide ONLY the enriched chunk text in your response:`;
-var CACHED_CODE_CHUNK_PROMPT_TEMPLATE = `
-Here is the chunk of code we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this code chunk by adding critical surrounding context. Follow these guidelines:
-
-1. Preserve ALL code syntax, indentation, and comments exactly as they appear
-2. Include any import statements, function definitions, or class declarations that this code depends on
-3. Add necessary type definitions or interfaces that are referenced in this chunk
-4. Include any crucial comments from elsewhere in the document that explain this code
-5. If there are key variable declarations or initializations earlier in the document, include those
-6. Keep the original chunk COMPLETELY INTACT and UNCHANGED in your response
-7. The total length should be between {min_tokens} and {max_tokens} tokens
-8. Do NOT include implementation details for functions that are only called but not defined in this chunk
-
-Provide ONLY the enriched code chunk in your response:`;
-var CACHED_MATH_PDF_PROMPT_TEMPLATE = `
-Here is the chunk we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this chunk by adding critical surrounding context. This document contains mathematical content that requires special handling. Follow these guidelines:
-
-1. Preserve ALL mathematical notation exactly as it appears in the chunk
-2. Include any defining equations, variables, or parameters mentioned earlier in the document that relate to this chunk
-3. Add section/subsection names or figure references if they help situate the chunk
-4. If variables or symbols are defined elsewhere in the document, include these definitions
-5. If mathematical expressions appear corrupted, try to infer their meaning from context
-6. Keep the original chunk text COMPLETELY INTACT and UNCHANGED in your response
-7. The total length should be between {min_tokens} and {max_tokens} tokens
-8. Format the response as a coherent mathematical explanation
-
-Provide ONLY the enriched chunk text in your response:`;
-var CACHED_TECHNICAL_PROMPT_TEMPLATE = `
-Here is the chunk we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this chunk by adding critical surrounding context. This appears to be technical documentation that requires special handling. Follow these guidelines:
-
-1. Preserve ALL technical terminology, product names, and version numbers exactly as they appear
-2. Include any prerequisite information or requirements mentioned earlier in the document
-3. Add section/subsection headings or navigation path to situate this chunk within the document structure
-4. Include any definitions of technical terms, acronyms, or jargon used in this chunk
-5. If this chunk references specific configurations, include relevant parameter explanations
-6. Keep the original chunk text COMPLETELY INTACT and UNCHANGED in your response
-7. The total length should be between {min_tokens} and {max_tokens} tokens
-8. Format the response maintaining any hierarchical structure present in the original
-
-Provide ONLY the enriched chunk text in your response:`;
-var MATH_PDF_PROMPT_TEMPLATE = `
-<document>
-{doc_content}
-</document>
-
-Here is the chunk we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this chunk by adding critical surrounding context. This document contains mathematical content that requires special handling. Follow these guidelines:
-
-1. Preserve ALL mathematical notation exactly as it appears in the chunk
-2. Include any defining equations, variables, or parameters mentioned earlier in the document that relate to this chunk
-3. Add section/subsection names or figure references if they help situate the chunk
-4. If variables or symbols are defined elsewhere in the document, include these definitions
-5. If mathematical expressions appear corrupted, try to infer their meaning from context
-6. Keep the original chunk text COMPLETELY INTACT and UNCHANGED in your response
-7. The total length should be between {min_tokens} and {max_tokens} tokens
-8. Format the response as a coherent mathematical explanation
-
-Provide ONLY the enriched chunk text in your response:`;
-var CODE_PROMPT_TEMPLATE = `
-<document>
-{doc_content}
-</document>
-
-Here is the chunk of code we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this code chunk by adding critical surrounding context. Follow these guidelines:
-
-1. Preserve ALL code syntax, indentation, and comments exactly as they appear
-2. Include any import statements, function definitions, or class declarations that this code depends on
-3. Add necessary type definitions or interfaces that are referenced in this chunk
-4. Include any crucial comments from elsewhere in the document that explain this code
-5. If there are key variable declarations or initializations earlier in the document, include those
-6. Keep the original chunk COMPLETELY INTACT and UNCHANGED in your response
-7. The total length should be between {min_tokens} and {max_tokens} tokens
-8. Do NOT include implementation details for functions that are only called but not defined in this chunk
-
-Provide ONLY the enriched code chunk in your response:`;
-var TECHNICAL_PROMPT_TEMPLATE = `
-<document>
-{doc_content}
-</document>
-
-Here is the chunk we want to situate within the whole document:
-<chunk>
-{chunk_content}
-</chunk>
-
-Create an enriched version of this chunk by adding critical surrounding context. This appears to be technical documentation that requires special handling. Follow these guidelines:
-
-1. Preserve ALL technical terminology, product names, and version numbers exactly as they appear
-2. Include any prerequisite information or requirements mentioned earlier in the document
-3. Add section/subsection headings or navigation path to situate this chunk within the document structure
-4. Include any definitions of technical terms, acronyms, or jargon used in this chunk
-5. If this chunk references specific configurations, include relevant parameter explanations
-6. Keep the original chunk text COMPLETELY INTACT and UNCHANGED in your response
-7. The total length should be between {min_tokens} and {max_tokens} tokens
-8. Format the response maintaining any hierarchical structure present in the original
-
-Provide ONLY the enriched chunk text in your response:`;
-function getContextualizationPrompt(docContent, chunkContent, minTokens = CONTEXT_TARGETS.DEFAULT.MIN_TOKENS, maxTokens = CONTEXT_TARGETS.DEFAULT.MAX_TOKENS, promptTemplate = CONTEXTUAL_CHUNK_ENRICHMENT_PROMPT_TEMPLATE) {
-  if (!docContent || !chunkContent) {
-    return "Error: Document or chunk content missing.";
-  }
-  const chunkTokens = Math.ceil(chunkContent.length / DEFAULT_CHARS_PER_TOKEN);
-  if (chunkTokens > maxTokens * 0.7) {
-    maxTokens = Math.ceil(chunkTokens * 1.3);
-    minTokens = chunkTokens;
-  }
-  return promptTemplate.replace("{doc_content}", docContent).replace("{chunk_content}", chunkContent).replace("{min_tokens}", minTokens.toString()).replace("{max_tokens}", maxTokens.toString());
-}
-function getCachingContextualizationPrompt(chunkContent, contentType, minTokens = CONTEXT_TARGETS.DEFAULT.MIN_TOKENS, maxTokens = CONTEXT_TARGETS.DEFAULT.MAX_TOKENS) {
-  if (!chunkContent) {
-    return {
-      prompt: "Error: Chunk content missing.",
-      systemPrompt: SYSTEM_PROMPTS.DEFAULT
-    };
-  }
-  const chunkTokens = Math.ceil(chunkContent.length / DEFAULT_CHARS_PER_TOKEN);
-  if (chunkTokens > maxTokens * 0.7) {
-    maxTokens = Math.ceil(chunkTokens * 1.3);
-    minTokens = chunkTokens;
-  }
-  let promptTemplate = CACHED_CHUNK_PROMPT_TEMPLATE;
-  let systemPrompt = SYSTEM_PROMPTS.DEFAULT;
-  if (contentType) {
-    if (contentType.includes("javascript") || contentType.includes("typescript") || contentType.includes("python") || contentType.includes("java") || contentType.includes("c++") || contentType.includes("code")) {
-      promptTemplate = CACHED_CODE_CHUNK_PROMPT_TEMPLATE;
-      systemPrompt = SYSTEM_PROMPTS.CODE;
-    } else if (contentType.includes("pdf")) {
-      if (containsMathematicalContent(chunkContent)) {
-        promptTemplate = CACHED_MATH_PDF_PROMPT_TEMPLATE;
-        systemPrompt = SYSTEM_PROMPTS.MATH_PDF;
-      } else {
-        systemPrompt = SYSTEM_PROMPTS.PDF;
-      }
-    } else if (contentType.includes("markdown") || contentType.includes("text/html") || isTechnicalDocumentation(chunkContent)) {
-      promptTemplate = CACHED_TECHNICAL_PROMPT_TEMPLATE;
-      systemPrompt = SYSTEM_PROMPTS.TECHNICAL;
-    }
-  }
-  const formattedPrompt = promptTemplate.replace("{chunk_content}", chunkContent).replace("{min_tokens}", minTokens.toString()).replace("{max_tokens}", maxTokens.toString());
-  return {
-    prompt: formattedPrompt,
-    systemPrompt
-  };
-}
-function getPromptForMimeType(mimeType, docContent, chunkContent) {
-  let minTokens = CONTEXT_TARGETS.DEFAULT.MIN_TOKENS;
-  let maxTokens = CONTEXT_TARGETS.DEFAULT.MAX_TOKENS;
-  let promptTemplate = CONTEXTUAL_CHUNK_ENRICHMENT_PROMPT_TEMPLATE;
-  if (mimeType.includes("pdf")) {
-    if (containsMathematicalContent(docContent)) {
-      minTokens = CONTEXT_TARGETS.MATH_PDF.MIN_TOKENS;
-      maxTokens = CONTEXT_TARGETS.MATH_PDF.MAX_TOKENS;
-      promptTemplate = MATH_PDF_PROMPT_TEMPLATE;
-    } else {
-      minTokens = CONTEXT_TARGETS.PDF.MIN_TOKENS;
-      maxTokens = CONTEXT_TARGETS.PDF.MAX_TOKENS;
-    }
-  } else if (mimeType.includes("javascript") || mimeType.includes("typescript") || mimeType.includes("python") || mimeType.includes("java") || mimeType.includes("c++") || mimeType.includes("code")) {
-    minTokens = CONTEXT_TARGETS.CODE.MIN_TOKENS;
-    maxTokens = CONTEXT_TARGETS.CODE.MAX_TOKENS;
-    promptTemplate = CODE_PROMPT_TEMPLATE;
-  } else if (isTechnicalDocumentation(docContent) || mimeType.includes("markdown") || mimeType.includes("text/html")) {
-    minTokens = CONTEXT_TARGETS.TECHNICAL.MIN_TOKENS;
-    maxTokens = CONTEXT_TARGETS.TECHNICAL.MAX_TOKENS;
-    promptTemplate = TECHNICAL_PROMPT_TEMPLATE;
-  }
-  return getContextualizationPrompt(docContent, chunkContent, minTokens, maxTokens, promptTemplate);
-}
-function getCachingPromptForMimeType(mimeType, chunkContent) {
-  let minTokens = CONTEXT_TARGETS.DEFAULT.MIN_TOKENS;
-  let maxTokens = CONTEXT_TARGETS.DEFAULT.MAX_TOKENS;
-  if (mimeType.includes("pdf")) {
-    if (containsMathematicalContent(chunkContent)) {
-      minTokens = CONTEXT_TARGETS.MATH_PDF.MIN_TOKENS;
-      maxTokens = CONTEXT_TARGETS.MATH_PDF.MAX_TOKENS;
-    } else {
-      minTokens = CONTEXT_TARGETS.PDF.MIN_TOKENS;
-      maxTokens = CONTEXT_TARGETS.PDF.MAX_TOKENS;
-    }
-  } else if (mimeType.includes("javascript") || mimeType.includes("typescript") || mimeType.includes("python") || mimeType.includes("java") || mimeType.includes("c++") || mimeType.includes("code")) {
-    minTokens = CONTEXT_TARGETS.CODE.MIN_TOKENS;
-    maxTokens = CONTEXT_TARGETS.CODE.MAX_TOKENS;
-  } else if (isTechnicalDocumentation(chunkContent) || mimeType.includes("markdown") || mimeType.includes("text/html")) {
-    minTokens = CONTEXT_TARGETS.TECHNICAL.MIN_TOKENS;
-    maxTokens = CONTEXT_TARGETS.TECHNICAL.MAX_TOKENS;
-  }
-  return getCachingContextualizationPrompt(chunkContent, mimeType, minTokens, maxTokens);
-}
-function containsMathematicalContent(content) {
-  const latexMathPatterns = [
-    /\$\$.+?\$\$/s,
-    /\$.+?\$/g,
-    /\\begin\{equation\}/,
-    /\\begin\{align\}/,
-    /\\sum_/,
-    /\\int/,
-    /\\frac\{/,
-    /\\sqrt\{/,
-    /\\alpha|\\beta|\\gamma|\\delta|\\theta|\\lambda|\\sigma/,
-    /\\nabla|\\partial/
-  ];
-  const generalMathPatterns = [
-    /[≠≤≥±∞∫∂∑∏√∈∉⊆⊇⊂⊃∪∩]/,
-    /\b[a-zA-Z]\^[0-9]/,
-    /\(\s*-?\d+(\.\d+)?\s*,\s*-?\d+(\.\d+)?\s*\)/,
-    /\b[xyz]\s*=\s*-?\d+(\.\d+)?/,
-    /\[\s*-?\d+(\.\d+)?\s*,\s*-?\d+(\.\d+)?\s*\]/,
-    /\b\d+\s*×\s*\d+/
-  ];
-  for (const pattern of latexMathPatterns) {
-    if (pattern.test(content)) {
-      return true;
-    }
-  }
-  for (const pattern of generalMathPatterns) {
-    if (pattern.test(content)) {
-      return true;
-    }
-  }
-  const mathKeywords = [
-    "theorem",
-    "lemma",
-    "proof",
-    "equation",
-    "function",
-    "derivative",
-    "integral",
-    "matrix",
-    "vector",
-    "algorithm",
-    "constraint",
-    "coefficient"
-  ];
-  const contentLower = content.toLowerCase();
-  const mathKeywordCount = mathKeywords.filter((keyword) => contentLower.includes(keyword)).length;
-  return mathKeywordCount >= 2;
-}
-function isTechnicalDocumentation(content) {
-  const technicalPatterns = [
-    /\b(version|v)\s*\d+\.\d+(\.\d+)?/i,
-    /\b(api|sdk|cli)\b/i,
-    /\b(http|https|ftp):\/\//i,
-    /\b(GET|POST|PUT|DELETE)\b/,
-    /<\/?[a-z][\s\S]*>/i,
-    /\bREADME\b|\bCHANGELOG\b/i,
-    /\b(config|configuration)\b/i,
-    /\b(parameter|param|argument|arg)\b/i
-  ];
-  const docHeadings = [
-    /\b(Introduction|Overview|Getting Started|Installation|Usage|API Reference|Troubleshooting)\b/i
-  ];
-  for (const pattern of [...technicalPatterns, ...docHeadings]) {
-    if (pattern.test(content)) {
-      return true;
-    }
-  }
-  const listPatterns = [/\d+\.\s.+\n\d+\.\s.+/, /•\s.+\n•\s.+/, /\*\s.+\n\*\s.+/, /-\s.+\n-\s.+/];
-  for (const pattern of listPatterns) {
-    if (pattern.test(content)) {
-      return true;
-    }
-  }
-  return false;
-}
-function getChunkWithContext(chunkContent, generatedContext) {
-  if (!generatedContext || generatedContext.trim() === "") {
-    return chunkContent;
-  }
-  return generatedContext.trim();
-}
-
-// llm.ts
-var import_anthropic = require("@ai-sdk/anthropic");
-var import_google = require("@ai-sdk/google");
-var import_openai = require("@ai-sdk/openai");
-var import_core2 = require("@elizaos/core");
-var import_ai_sdk_provider = require("@openrouter/ai-sdk-provider");
-var import_ai = require("ai");
-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;
-  const autoCacheContextualRetrieval = overrideConfig?.autoCacheContextualRetrieval !== false;
-  if (!modelName) {
-    throw new Error(`No model name configured for provider: ${provider}`);
-  }
-  try {
-    switch (provider) {
-      case "anthropic":
-        return await generateAnthropicText(config, prompt, system, modelName, maxTokens);
-      case "openai":
-        return await generateOpenAIText(config, prompt, system, modelName, maxTokens);
-      case "openrouter":
-        return await generateOpenRouterText(config, prompt, system, modelName, maxTokens, overrideConfig?.cacheDocument, overrideConfig?.cacheOptions, autoCacheContextualRetrieval);
-      case "google":
-        return await generateGoogleText(prompt, system, modelName, maxTokens, config);
-      default:
-        throw new Error(`Unsupported text provider: ${provider}`);
-    }
-  } catch (error) {
-    import_core2.logger.error({ error }, `${provider} ${modelName} error`);
-    throw error;
-  }
-}
-async function generateAnthropicText(config, prompt, system, modelName, maxTokens) {
-  const anthropic = import_anthropic.createAnthropic({
-    apiKey: config.ANTHROPIC_API_KEY,
-    baseURL: config.ANTHROPIC_BASE_URL
-  });
-  const modelInstance = anthropic(modelName);
-  const maxRetries = 3;
-  for (let attempt = 0;attempt < maxRetries; attempt++) {
-    try {
-      return await import_ai.generateText({
-        model: modelInstance,
-        prompt,
-        system,
-        temperature: 0.3,
-        maxOutputTokens: maxTokens
-      });
-    } catch (error) {
-      const errorObj = error;
-      const isRateLimit = errorObj?.status === 429 || errorObj?.message?.includes("rate limit") || errorObj?.message?.includes("429");
-      if (isRateLimit && attempt < maxRetries - 1) {
-        const delay = 2 ** (attempt + 1) * 1000;
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
-        continue;
-      }
-      throw error;
-    }
-  }
-  throw new Error("Max retries exceeded for Anthropic text generation");
-}
-async function generateOpenAIText(config, prompt, system, modelName, maxTokens) {
-  const openai = import_openai.createOpenAI({
-    apiKey: config.OPENAI_API_KEY,
-    baseURL: config.OPENAI_BASE_URL
-  });
-  const modelInstance = openai.chat(modelName);
-  const result = await import_ai.generateText({
-    model: modelInstance,
-    prompt,
-    system,
-    temperature: 0.3,
-    maxOutputTokens: maxTokens
-  });
-  return result;
-}
-async function generateGoogleText(prompt, system, modelName, maxTokens, config) {
-  const googleProvider = import_google.google;
-  if (config.GOOGLE_API_KEY) {
-    process.env.GOOGLE_GENERATIVE_AI_API_KEY = config.GOOGLE_API_KEY;
-  }
-  const modelInstance = googleProvider(modelName);
-  const result = await import_ai.generateText({
-    model: modelInstance,
-    prompt,
-    system,
-    temperature: 0.3,
-    maxOutputTokens: maxTokens
-  });
-  return result;
-}
-async function generateOpenRouterText(config, prompt, system, modelName, maxTokens, cacheDocument, _cacheOptions, autoCacheContextualRetrieval = true) {
-  const openrouter = import_ai_sdk_provider.createOpenRouter({
-    apiKey: config.OPENROUTER_API_KEY,
-    baseURL: config.OPENROUTER_BASE_URL
-  });
-  const modelInstance = openrouter.chat(modelName);
-  const isClaudeModel = modelName.toLowerCase().includes("claude");
-  const isGeminiModel = modelName.toLowerCase().includes("gemini");
-  const isGemini25Model = modelName.toLowerCase().includes("gemini-2.5");
-  const supportsCaching = isClaudeModel || isGeminiModel;
-  let documentForCaching = cacheDocument;
-  if (!documentForCaching && autoCacheContextualRetrieval && supportsCaching) {
-    const docMatch = prompt.match(/<document>([\s\S]*?)<\/document>/);
-    if (docMatch?.[1]) {
-      documentForCaching = docMatch[1].trim();
-    }
-  }
-  if (documentForCaching && supportsCaching) {
-    let promptText = prompt;
-    if (promptText.includes("<document>")) {
-      promptText = promptText.replace(/<document>[\s\S]*?<\/document>/, "").trim();
-    }
-    if (isClaudeModel) {
-      return await generateClaudeWithCaching(promptText, system, modelInstance, modelName, maxTokens, documentForCaching);
-    } else if (isGeminiModel) {
-      return await generateGeminiWithCaching(promptText, system, modelInstance, modelName, maxTokens, documentForCaching, isGemini25Model);
-    }
-  }
-  return await generateStandardOpenRouterText(prompt, system, modelInstance, modelName, maxTokens);
-}
-async function generateClaudeWithCaching(promptText, system, modelInstance, modelName, maxTokens, documentForCaching) {
-  const messages = [
-    system ? {
-      role: "system",
-      content: [
-        {
-          type: "text",
-          text: system
-        },
-        {
-          type: "text",
-          text: documentForCaching,
-          cache_control: {
-            type: "ephemeral"
-          }
-        }
-      ]
-    } : {
-      role: "user",
-      content: [
-        {
-          type: "text",
-          text: "Document for context:"
-        },
-        {
-          type: "text",
-          text: documentForCaching,
-          cache_control: {
-            type: "ephemeral"
-          }
-        },
-        {
-          type: "text",
-          text: promptText
-        }
-      ]
-    },
-    system ? {
-      role: "user",
-      content: [
-        {
-          type: "text",
-          text: promptText
-        }
-      ]
-    } : null
-  ].filter(Boolean);
-  const result = await import_ai.generateText({
-    model: modelInstance,
-    messages,
-    temperature: 0.3,
-    maxOutputTokens: maxTokens,
-    providerOptions: {
-      openrouter: {
-        usage: {
-          include: true
-        }
-      }
-    }
-  });
-  logCacheMetrics(result);
-  const totalTokens = (result.usage.inputTokens || 0) + (result.usage.outputTokens || 0);
-  import_core2.logger.debug(`OpenRouter ${modelName}: ${totalTokens} tokens (${result.usage.inputTokens || 0}→${result.usage.outputTokens || 0})`);
-  return result;
-}
-async function generateGeminiWithCaching(promptText, system, modelInstance, modelName, maxTokens, documentForCaching, _isGemini25Model) {
-  const geminiSystemPrefix = system ? `${system}
-
-` : "";
-  const geminiPrompt = `${geminiSystemPrefix}${documentForCaching}
-
-${promptText}`;
-  const result = await import_ai.generateText({
-    model: modelInstance,
-    prompt: geminiPrompt,
-    temperature: 0.3,
-    maxOutputTokens: maxTokens,
-    providerOptions: {
-      openrouter: {
-        usage: {
-          include: true
-        }
-      }
-    }
-  });
-  logCacheMetrics(result);
-  const totalTokens = (result.usage.inputTokens || 0) + (result.usage.outputTokens || 0);
-  import_core2.logger.debug(`OpenRouter ${modelName}: ${totalTokens} tokens (${result.usage.inputTokens || 0}→${result.usage.outputTokens || 0})`);
-  return result;
-}
-async function generateStandardOpenRouterText(prompt, system, modelInstance, modelName, maxTokens) {
-  const result = await import_ai.generateText({
-    model: modelInstance,
-    prompt,
-    system,
-    temperature: 0.3,
-    maxOutputTokens: maxTokens,
-    providerOptions: {
-      openrouter: {
-        usage: {
-          include: true
-        }
-      }
-    }
-  });
-  const totalTokens = (result.usage.inputTokens || 0) + (result.usage.outputTokens || 0);
-  import_core2.logger.debug(`OpenRouter ${modelName}: ${totalTokens} tokens (${result.usage.inputTokens || 0}→${result.usage.outputTokens || 0})`);
-  return result;
-}
-function logCacheMetrics(_result) {}
-
-// document-processor.ts
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function getCtxKnowledgeEnabled(runtime) {
-  let result;
-  let _source;
-  let rawValue;
-  if (runtime) {
-    const settingValue = runtime.getSetting("CTX_KNOWLEDGE_ENABLED");
-    rawValue = typeof settingValue === "string" ? settingValue : settingValue?.toString();
-    const cleanValue = rawValue?.trim().toLowerCase();
-    result = cleanValue === "true";
-  } else {
-    rawValue = process.env.CTX_KNOWLEDGE_ENABLED;
-    const cleanValue = rawValue?.toString().trim().toLowerCase();
-    result = cleanValue === "true";
-  }
-  return result;
-}
-function shouldUseCustomLLM() {
-  const textProvider = process.env.TEXT_PROVIDER;
-  const textModel = process.env.TEXT_MODEL;
-  if (!textProvider || !textModel) {
-    return false;
-  }
-  switch (textProvider.toLowerCase()) {
-    case "openrouter":
-      return !!process.env.OPENROUTER_API_KEY;
-    case "openai":
-      return !!process.env.OPENAI_API_KEY;
-    case "anthropic":
-      return !!process.env.ANTHROPIC_API_KEY;
-    case "google":
-      return !!process.env.GOOGLE_API_KEY;
-    default:
-      return false;
-  }
-}
-var useCustomLLM = shouldUseCustomLLM();
-async function processFragmentsSynchronously({
-  runtime,
-  documentId,
-  fullDocumentText,
-  agentId,
-  contentType,
-  roomId,
-  entityId,
-  worldId,
-  documentTitle
-}) {
-  if (!fullDocumentText || fullDocumentText.trim() === "") {
-    import_core3.logger.warn(`No text content available for document ${documentId}`);
-    return 0;
-  }
-  const chunks = await splitDocumentIntoChunks(fullDocumentText);
-  if (chunks.length === 0) {
-    import_core3.logger.warn(`No chunks generated for document ${documentId}`);
-    return 0;
-  }
-  import_core3.logger.info(`Split into ${chunks.length} chunks`);
-  const providerLimits = await getProviderRateLimits(runtime);
-  const CONCURRENCY_LIMIT = providerLimits.maxConcurrentRequests || 30;
-  const rateLimiter = createRateLimiter(providerLimits.requestsPerMinute || 60, providerLimits.tokensPerMinute, providerLimits.rateLimitEnabled);
-  const { savedCount, failedCount } = await processAndSaveFragments({
-    runtime,
-    documentId,
-    chunks,
-    fullDocumentText,
-    contentType,
-    agentId,
-    roomId: roomId || agentId,
-    entityId: entityId || agentId,
-    worldId: worldId || agentId,
-    concurrencyLimit: CONCURRENCY_LIMIT,
-    rateLimiter,
-    documentTitle,
-    batchDelayMs: providerLimits.batchDelayMs
-  });
-  if (failedCount > 0) {
-    import_core3.logger.warn(`${failedCount}/${chunks.length} chunks failed processing`);
-  }
-  return savedCount;
-}
-async function extractTextFromDocument(fileBuffer, contentType, originalFilename) {
-  if (!fileBuffer || fileBuffer.length === 0) {
-    throw new Error(`Empty file buffer provided for ${originalFilename}`);
-  }
-  try {
-    if (contentType === "application/pdf") {
-      import_core3.logger.debug(`Extracting text from PDF: ${originalFilename}`);
-      return await convertPdfToTextFromBuffer(fileBuffer, originalFilename);
-    } else {
-      if (contentType.includes("text/") || contentType.includes("application/json") || contentType.includes("application/xml")) {
-        try {
-          return fileBuffer.toString("utf8");
-        } catch (_textError) {
-          import_core3.logger.warn(`Failed to decode ${originalFilename} as UTF-8`);
-        }
-      }
-      return await extractTextFromFileBuffer(fileBuffer, contentType, originalFilename);
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    import_core3.logger.error(`Error extracting text from ${originalFilename}: ${errorMessage}`);
-    throw new Error(`Failed to extract text from ${originalFilename}: ${errorMessage}`);
-  }
-}
-function createDocumentMemory({
-  text,
-  agentId,
-  clientDocumentId,
-  originalFilename,
-  contentType,
-  worldId,
-  fileSize,
-  documentId,
-  customMetadata
-}) {
-  const fileExt = originalFilename.split(".").pop()?.toLowerCase() || "";
-  const title = originalFilename.replace(`.${fileExt}`, "");
-  const docId = documentId || v4_default();
-  return {
-    id: docId,
-    agentId,
-    roomId: agentId,
-    worldId,
-    entityId: agentId,
-    content: { text },
-    metadata: {
-      type: import_core3.MemoryType.CUSTOM,
-      documentId: clientDocumentId,
-      originalFilename,
-      contentType,
-      title,
-      fileExt,
-      fileSize,
-      source: "rag-service-main-upload",
-      timestamp: Date.now(),
-      ...customMetadata || {}
-    }
-  };
-}
-async function splitDocumentIntoChunks(documentText) {
-  const tokenChunkSize = DEFAULT_CHUNK_TOKEN_SIZE;
-  const tokenChunkOverlap = DEFAULT_CHUNK_OVERLAP_TOKENS;
-  return await import_core3.splitChunks(documentText, tokenChunkSize, tokenChunkOverlap);
-}
-async function processAndSaveFragments({
-  runtime,
-  documentId,
-  chunks,
-  fullDocumentText,
-  contentType,
-  agentId,
-  roomId,
-  entityId,
-  worldId,
-  concurrencyLimit,
-  rateLimiter,
-  documentTitle,
-  batchDelayMs = 500
-}) {
-  let savedCount = 0;
-  let failedCount = 0;
-  const failedChunks = [];
-  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);
-    const contextualizedChunks = await getContextualizedChunks(runtime, fullDocumentText, batchChunks, contentType, batchOriginalIndices, documentTitle);
-    const embeddingResults = await generateEmbeddingsForChunks(runtime, contextualizedChunks, rateLimiter);
-    for (const result of embeddingResults) {
-      const originalChunkIndex = result.index;
-      if (!result.success) {
-        failedCount++;
-        failedChunks.push(originalChunkIndex);
-        import_core3.logger.warn(`Failed to process chunk ${originalChunkIndex} for document ${documentId}`);
-        continue;
-      }
-      const contextualizedChunkText = result.text;
-      const embedding = result.embedding;
-      if (!embedding || embedding.length === 0) {
-        failedCount++;
-        failedChunks.push(originalChunkIndex);
-        continue;
-      }
-      try {
-        const fragmentMemory = {
-          id: v4_default(),
-          agentId,
-          roomId: roomId || agentId,
-          worldId: worldId || agentId,
-          entityId: entityId || agentId,
-          embedding,
-          content: { text: contextualizedChunkText },
-          metadata: {
-            type: import_core3.MemoryType.FRAGMENT,
-            documentId,
-            position: originalChunkIndex,
-            timestamp: Date.now(),
-            source: "rag-service-fragment-sync"
-          }
-        };
-        await runtime.createMemory(fragmentMemory, "knowledge");
-        savedCount++;
-      } catch (saveError) {
-        const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
-        import_core3.logger.error(`Error saving chunk ${originalChunkIndex} to database: ${errorMessage}`);
-        failedCount++;
-        failedChunks.push(originalChunkIndex);
-      }
-    }
-    if (i + concurrencyLimit < chunks.length && batchDelayMs > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, batchDelayMs));
-    }
-  }
-  return { savedCount, failedCount, failedChunks };
-}
-var EMBEDDING_BATCH_SIZE = 100;
-async function generateEmbeddingsForChunks(runtime, contextualizedChunks, rateLimiter) {
-  const validChunks = contextualizedChunks.filter((chunk) => chunk.success);
-  const failedChunks = contextualizedChunks.filter((chunk) => !chunk.success);
-  const results = [];
-  for (const chunk of failedChunks) {
-    results.push({
-      success: false,
-      index: chunk.index,
-      error: new Error("Chunk processing failed"),
-      text: chunk.contextualizedText
-    });
-  }
-  if (validChunks.length === 0) {
-    return results;
-  }
-  const useBatchEmbeddings = shouldUseBatchEmbeddings(runtime);
-  if (useBatchEmbeddings) {
-    return await generateEmbeddingsBatch(runtime, validChunks, rateLimiter, results);
-  } else {
-    return await generateEmbeddingsIndividual(runtime, validChunks, rateLimiter, results);
-  }
-}
-function shouldUseBatchEmbeddings(runtime) {
-  const setting = runtime.getSetting("BATCH_EMBEDDINGS") ?? process.env.BATCH_EMBEDDINGS;
-  return setting === "true" || setting === true;
-}
-async function generateEmbeddingsBatch(runtime, validChunks, rateLimiter, results) {
-  for (let batchStart = 0;batchStart < validChunks.length; batchStart += EMBEDDING_BATCH_SIZE) {
-    const batchEnd = Math.min(batchStart + EMBEDDING_BATCH_SIZE, validChunks.length);
-    const batch = validChunks.slice(batchStart, batchEnd);
-    const batchTexts = batch.map((c) => c.contextualizedText);
-    const totalTokens = batchTexts.reduce((sum, text) => sum + estimateTokens(text), 0);
-    await rateLimiter(totalTokens);
-    try {
-      const embeddings = await generateBatchEmbeddingsViaRuntime(runtime, batchTexts);
-      for (let i = 0;i < batch.length; i++) {
-        const chunk = batch[i];
-        const embedding = embeddings[i];
-        if (embedding && embedding.length > 0 && embedding[0] !== 0) {
-          results.push({
-            embedding,
-            success: true,
-            index: chunk.index,
-            text: chunk.contextualizedText
-          });
-        } else {
-          results.push({
-            success: false,
-            index: chunk.index,
-            error: new Error("Empty or invalid embedding returned"),
-            text: chunk.contextualizedText
-          });
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      import_core3.logger.error(`Batch embedding error: ${errorMessage}`);
-      for (const chunk of batch) {
-        try {
-          const result = await generateEmbeddingWithValidation(runtime, chunk.contextualizedText);
-          if (result.success && result.embedding) {
-            results.push({
-              embedding: result.embedding,
-              success: true,
-              index: chunk.index,
-              text: chunk.contextualizedText
-            });
-          } else {
-            results.push({
-              success: false,
-              index: chunk.index,
-              error: result.error instanceof Error ? result.error : new Error("Embedding failed"),
-              text: chunk.contextualizedText
-            });
-          }
-        } catch (fallbackError) {
-          results.push({
-            success: false,
-            index: chunk.index,
-            error: fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError)),
-            text: chunk.contextualizedText
-          });
-        }
-      }
-    }
-  }
-  return results;
-}
-async function generateBatchEmbeddingsViaRuntime(runtime, texts) {
-  const batchResult = await runtime.useModel(import_core3.ModelType.TEXT_EMBEDDING, { texts });
-  const isEmbeddingBatch = (val) => Array.isArray(val) && val.length > 0 && Array.isArray(val[0]) && typeof val[0][0] === "number";
-  const isEmbeddingVector = (val) => Array.isArray(val) && val.length > 0 && typeof val[0] === "number";
-  if (isEmbeddingBatch(batchResult)) {
-    return batchResult;
-  }
-  if (isEmbeddingVector(batchResult)) {
-    const embeddings = await Promise.all(texts.map(async (text) => {
-      const result = await runtime.useModel(import_core3.ModelType.TEXT_EMBEDDING, { text });
-      if (isEmbeddingVector(result)) {
-        return result;
-      }
-      const embeddingResult = result;
-      return embeddingResult?.embedding ?? [];
-    }));
-    return embeddings;
-  }
-  throw new Error("Unexpected batch embedding result format");
-}
-async function generateEmbeddingsIndividual(runtime, validChunks, rateLimiter, results) {
-  for (const chunk of validChunks) {
-    const embeddingTokens = estimateTokens(chunk.contextualizedText);
-    await rateLimiter(embeddingTokens);
-    try {
-      const generateEmbeddingOperation = async () => {
-        return await generateEmbeddingWithValidation(runtime, chunk.contextualizedText);
-      };
-      const { embedding, success, error } = await withRateLimitRetry(generateEmbeddingOperation, `embedding generation for chunk ${chunk.index}`);
-      if (!success) {
-        results.push({
-          success: false,
-          index: chunk.index,
-          error,
-          text: chunk.contextualizedText
-        });
-      } else {
-        results.push({
-          embedding: embedding ?? undefined,
-          success: true,
-          index: chunk.index,
-          text: chunk.contextualizedText
-        });
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      import_core3.logger.error(`Error generating embedding for chunk ${chunk.index}: ${errorMessage}`);
-      results.push({
-        success: false,
-        index: chunk.index,
-        error: error instanceof Error ? error : new Error(String(error)),
-        text: chunk.contextualizedText
-      });
-    }
-  }
-  return results;
-}
-async function getContextualizedChunks(runtime, fullDocumentText, chunks, contentType, batchOriginalIndices, documentTitle) {
-  const ctxEnabled = getCtxKnowledgeEnabled(runtime);
-  if (ctxEnabled && fullDocumentText) {
-    return await generateContextsInBatch(runtime, fullDocumentText, chunks, contentType, batchOriginalIndices, documentTitle);
-  }
-  return chunks.map((chunkText, idx) => ({
-    contextualizedText: chunkText,
-    index: batchOriginalIndices[idx],
-    success: true
-  }));
-}
-async function generateContextsInBatch(runtime, fullDocumentText, chunks, contentType, batchIndices, _documentTitle) {
-  if (!chunks || chunks.length === 0) {
-    return [];
-  }
-  const providerLimits = await getProviderRateLimits(runtime);
-  const rateLimiter = createRateLimiter(providerLimits.requestsPerMinute || 60, providerLimits.tokensPerMinute, providerLimits.rateLimitEnabled);
-  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"));
-  import_core3.logger.debug(`Contextualizing ${chunks.length} chunks with ${config.TEXT_PROVIDER}/${config.TEXT_MODEL} (cache: ${isUsingCacheCapableModel})`);
-  const promptConfigs = prepareContextPrompts(chunks, fullDocumentText, contentType, batchIndices, isUsingCacheCapableModel);
-  const contextualizedChunks = await Promise.all(promptConfigs.map(async (item) => {
-    if (!item.valid) {
-      return {
-        contextualizedText: item.chunkText,
-        success: false,
-        index: item.originalIndex
-      };
-    }
-    const llmTokens = estimateTokens(item.chunkText + (item.prompt || ""));
-    await rateLimiter(llmTokens);
-    try {
-      const generateTextOperation = async () => {
-        if (useCustomLLM) {
-          if (item.usesCaching && item.promptText) {
-            return await generateText(runtime, item.promptText, item.systemPrompt, {
-              cacheDocument: item.fullDocumentTextForContext,
-              cacheOptions: { type: "ephemeral" },
-              autoCacheContextualRetrieval: true
-            });
-          } else if (item.prompt) {
-            return await generateText(runtime, item.prompt);
-          }
-          throw new Error("Missing prompt for text generation");
-        } else {
-          if (item.usesCaching && item.promptText) {
-            const combinedPrompt = item.systemPrompt ? `${item.systemPrompt}
-
-${item.promptText}` : item.promptText;
-            return await runtime.useModel(import_core3.ModelType.TEXT_LARGE, {
-              prompt: combinedPrompt
-            });
-          } else if (item.prompt) {
-            return await runtime.useModel(import_core3.ModelType.TEXT_LARGE, {
-              prompt: item.prompt
-            });
-          }
-          throw new Error("Missing prompt for text generation");
-        }
-      };
-      const llmResponse = await withRateLimitRetry(generateTextOperation, `context generation for chunk ${item.originalIndex}`);
-      const generatedContext = typeof llmResponse === "string" ? llmResponse : llmResponse.text;
-      const contextualizedText = getChunkWithContext(item.chunkText, generatedContext);
-      return {
-        contextualizedText,
-        success: true,
-        index: item.originalIndex
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      import_core3.logger.error(`Error generating context for chunk ${item.originalIndex}: ${errorMessage}`);
-      return {
-        contextualizedText: item.chunkText,
-        success: false,
-        index: item.originalIndex
-      };
-    }
-  }));
-  return contextualizedChunks;
-}
-function prepareContextPrompts(chunks, fullDocumentText, contentType, batchIndices, isUsingCacheCapableModel = false) {
-  return chunks.map((chunkText, idx) => {
-    const originalIndex = batchIndices ? batchIndices[idx] : idx;
-    try {
-      if (isUsingCacheCapableModel) {
-        const cachingPromptInfo = contentType ? getCachingPromptForMimeType(contentType, chunkText) : getCachingContextualizationPrompt(chunkText);
-        if (cachingPromptInfo.prompt.startsWith("Error:")) {
-          return {
-            originalIndex,
-            chunkText,
-            valid: false,
-            usesCaching: false
-          };
-        }
-        return {
-          valid: true,
-          originalIndex,
-          chunkText,
-          usesCaching: true,
-          systemPrompt: cachingPromptInfo.systemPrompt,
-          promptText: cachingPromptInfo.prompt,
-          fullDocumentTextForContext: fullDocumentText
-        };
-      } else {
-        const prompt = contentType ? getPromptForMimeType(contentType, fullDocumentText, chunkText) : getContextualizationPrompt(fullDocumentText, chunkText);
-        if (prompt.startsWith("Error:")) {
-          return {
-            prompt: null,
-            originalIndex,
-            chunkText,
-            valid: false,
-            usesCaching: false
-          };
-        }
-        return {
-          prompt,
-          originalIndex,
-          chunkText,
-          valid: true,
-          usesCaching: false
-        };
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      import_core3.logger.error(`Error preparing prompt for chunk ${originalIndex}: ${errorMessage}`);
-      return {
-        prompt: null,
-        originalIndex,
-        chunkText,
-        valid: false,
-        usesCaching: false
-      };
-    }
-  });
-}
-async function generateEmbeddingWithValidation(runtime, text) {
-  try {
-    const embeddingResult = await runtime.useModel(import_core3.ModelType.TEXT_EMBEDDING, { text });
-    const embedding = Array.isArray(embeddingResult) ? embeddingResult : embeddingResult?.embedding;
-    if (!embedding || embedding.length === 0) {
-      return { embedding: null, success: false, error: new Error("Zero vector detected") };
-    }
-    return { embedding, success: true };
-  } catch (error) {
-    return {
-      embedding: null,
-      success: false,
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-}
-async function withRateLimitRetry(operation, errorContext, retryDelay) {
-  try {
-    return await operation();
-  } catch (error) {
-    const errorWithStatus = error;
-    if (errorWithStatus.status === 429) {
-      const delay = retryDelay || errorWithStatus.headers?.["retry-after"] || 5;
-      await new Promise((resolve2) => setTimeout(resolve2, delay * 1000));
-      try {
-        return await operation();
-      } catch (retryError) {
-        const retryErrorMessage = retryError instanceof Error ? retryError.message : String(retryError);
-        import_core3.logger.error(`Failed after retry for ${errorContext}: ${retryErrorMessage}`);
-        throw retryError;
-      }
-    }
-    throw error;
-  }
-}
-function createRateLimiter(requestsPerMinute, tokensPerMinute, rateLimitEnabled = true) {
-  const requestTimes = [];
-  const tokenUsage = [];
-  const intervalMs = 60 * 1000;
-  return async function rateLimiter(estimatedTokens = 1000) {
-    if (!rateLimitEnabled)
-      return;
-    const now = Date.now();
-    while (requestTimes.length > 0 && now - requestTimes[0] > intervalMs) {
-      requestTimes.shift();
-    }
-    while (tokenUsage.length > 0 && now - tokenUsage[0].timestamp > intervalMs) {
-      tokenUsage.shift();
-    }
-    const currentTokens = tokenUsage.reduce((sum, usage) => sum + usage.tokens, 0);
-    const requestLimitExceeded = requestTimes.length >= requestsPerMinute;
-    const tokenLimitExceeded = tokensPerMinute && currentTokens + estimatedTokens > tokensPerMinute;
-    if (requestLimitExceeded || tokenLimitExceeded) {
-      let timeToWait = 0;
-      if (requestLimitExceeded) {
-        timeToWait = Math.max(timeToWait, requestTimes[0] + intervalMs - now);
-      }
-      if (tokenLimitExceeded && tokenUsage.length > 0) {
-        timeToWait = Math.max(timeToWait, tokenUsage[0].timestamp + intervalMs - now);
-      }
-      if (timeToWait > 0) {
-        await new Promise((resolve2) => setTimeout(resolve2, timeToWait));
-      }
-    }
-    requestTimes.push(now);
-    if (tokensPerMinute) {
-      tokenUsage.push({ timestamp: now, tokens: estimatedTokens });
-    }
-  };
-}
-
-// service.ts
-class KnowledgeService extends import_core4.Service {
-  static serviceType = "knowledge";
-  config = {};
-  capabilityDescription = "Provides Retrieval Augmented Generation capabilities, including knowledge upload and querying.";
-  knowledgeProcessingSemaphore;
-  constructor(runtime, _config) {
-    super(runtime);
-    this.knowledgeProcessingSemaphore = new import_core4.Semaphore(10);
-  }
-  async loadInitialDocuments() {
-    import_core4.logger.info(`Loading documents on startup for agent ${this.runtime.agentId}`);
-    try {
-      await new Promise((resolve2) => setTimeout(resolve2, 1000));
-      const knowledgePathSetting = this.runtime.getSetting("KNOWLEDGE_PATH");
-      const knowledgePath = typeof knowledgePathSetting === "string" ? knowledgePathSetting : undefined;
-      const result = await loadDocsFromPath(this, this.runtime.agentId, undefined, knowledgePath);
-      if (result.successful > 0) {
-        import_core4.logger.info(`Loaded ${result.successful} documents on startup`);
-      }
-    } catch (error) {
-      import_core4.logger.error({ error }, "Error loading documents on startup");
-    }
-  }
-  static async start(runtime) {
-    import_core4.logger.info(`Starting Knowledge service for agent: ${runtime.agentId}`);
-    const validatedConfig = validateModelConfig(runtime);
-    const ctxEnabled = validatedConfig.CTX_KNOWLEDGE_ENABLED;
-    if (ctxEnabled) {
-      import_core4.logger.info(`Contextual Knowledge enabled: ${validatedConfig.EMBEDDING_PROVIDER || "auto"} embeddings, ${validatedConfig.TEXT_PROVIDER} text generation`);
-      import_core4.logger.info(`Text model: ${validatedConfig.TEXT_MODEL}`);
-    } else {
-      const usingPluginOpenAI = !process.env.EMBEDDING_PROVIDER;
-      import_core4.logger.warn("Basic Embedding mode - documents will not be enriched with context");
-      import_core4.logger.info("To enable contextual enrichment: Set CTX_KNOWLEDGE_ENABLED=true and configure TEXT_PROVIDER/TEXT_MODEL");
-      if (usingPluginOpenAI) {
-        import_core4.logger.info("Using plugin-openai configuration for embeddings");
-      } else {
-        import_core4.logger.info(`Using ${validatedConfig.EMBEDDING_PROVIDER} for embeddings with ${validatedConfig.TEXT_EMBEDDING_MODEL}`);
-      }
-    }
-    const service = new KnowledgeService(runtime);
-    service.config = validatedConfig;
-    if (service.config.LOAD_DOCS_ON_STARTUP) {
-      service.loadInitialDocuments().catch((error) => {
-        import_core4.logger.error({ error }, "Error loading initial documents");
-      });
-    }
-    if (service.runtime.character?.knowledge && service.runtime.character.knowledge.length > 0) {
-      const stringKnowledge = service.runtime.character.knowledge.map((item) => {
-        const itemAny = item;
-        if (itemAny?.item?.case === "path" && typeof itemAny.item.value === "string") {
-          return itemAny.item.value;
-        }
-        if (typeof itemAny?.path === "string") {
-          return itemAny.path;
-        }
-        if (typeof item === "string") {
-          return item;
-        }
-        return null;
-      }).filter((item) => item !== null);
-      await service.processCharacterKnowledge(stringKnowledge).catch((err) => {
-        import_core4.logger.error({ error: err }, "Error processing character knowledge");
-      });
-    }
-    return service;
-  }
-  static async stop(runtime) {
-    import_core4.logger.info(`Stopping Knowledge service for agent: ${runtime.agentId}`);
-    const service = runtime.getService(KnowledgeService.serviceType);
-    if (!service) {
-      import_core4.logger.warn(`KnowledgeService not found for agent ${runtime.agentId} during stop.`);
-    }
-    if (service instanceof KnowledgeService) {
-      await service.stop();
-    }
-  }
-  async stop() {
-    import_core4.logger.info(`Knowledge service stopping for agent: ${this.runtime.character?.name}`);
-  }
-  async addKnowledge(options) {
-    const agentId = options.agentId || this.runtime.agentId;
-    const contentBasedId = generateContentBasedId(options.content, agentId, {
-      includeFilename: options.originalFilename,
-      contentType: options.contentType,
-      maxChars: 2000
-    });
-    import_core4.logger.info(`Processing "${options.originalFilename}" (${options.contentType})`);
-    try {
-      const existingDocument = await this.runtime.getMemoryById(contentBasedId);
-      if (existingDocument && existingDocument.metadata?.type === import_core4.MemoryType.DOCUMENT) {
-        import_core4.logger.info(`"${options.originalFilename}" already exists - skipping`);
-        const fragments = await this.runtime.getMemories({
-          tableName: "knowledge"
-        });
-        const relatedFragments = fragments.filter((f) => f.metadata?.type === import_core4.MemoryType.FRAGMENT && f.metadata.documentId === contentBasedId);
-        return {
-          clientDocumentId: contentBasedId,
-          storedDocumentMemoryId: existingDocument.id,
-          fragmentCount: relatedFragments.length
-        };
-      }
-    } catch (error) {
-      import_core4.logger.debug(`Document ${contentBasedId} not found or error checking existence, proceeding with processing: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return this.processDocument({
-      ...options,
-      clientDocumentId: contentBasedId
-    });
-  }
-  async processDocument({
-    agentId: passedAgentId,
-    clientDocumentId,
-    contentType,
-    originalFilename,
-    worldId,
-    content,
-    roomId,
-    entityId,
-    metadata
-  }) {
-    const agentId = passedAgentId || this.runtime.agentId;
-    try {
-      import_core4.logger.debug(`Processing document ${originalFilename} (type: ${contentType}) for agent: ${agentId}`);
-      let fileBuffer = null;
-      let extractedText;
-      let documentContentToStore;
-      const isPdfFile = contentType === "application/pdf" || originalFilename.toLowerCase().endsWith(".pdf");
-      if (isPdfFile) {
-        try {
-          fileBuffer = Buffer.from(content, "base64");
-        } catch (e) {
-          import_core4.logger.error({ error: e }, `Failed to convert base64 to buffer for ${originalFilename}`);
-          throw new Error(`Invalid base64 content for PDF file ${originalFilename}`);
-        }
-        extractedText = await extractTextFromDocument(fileBuffer, contentType, originalFilename);
-        documentContentToStore = content;
-      } else if (isBinaryContentType(contentType, originalFilename)) {
-        try {
-          fileBuffer = Buffer.from(content, "base64");
-        } catch (e) {
-          import_core4.logger.error({ error: e }, `Failed to convert base64 to buffer for ${originalFilename}`);
-          throw new Error(`Invalid base64 content for binary file ${originalFilename}`);
-        }
-        extractedText = await extractTextFromDocument(fileBuffer, contentType, originalFilename);
-        documentContentToStore = extractedText;
-      } else {
-        if (looksLikeBase64(content)) {
-          try {
-            const decodedBuffer = Buffer.from(content, "base64");
-            const decodedText = decodedBuffer.toString("utf8");
-            const invalidCharCount = (decodedText.match(/\ufffd/g) || []).length;
-            const textLength = decodedText.length;
-            if (invalidCharCount > 0 && invalidCharCount / textLength > 0.1) {
-              throw new Error("Decoded content contains too many invalid characters");
-            }
-            import_core4.logger.debug(`Successfully decoded base64 content for text file: ${originalFilename}`);
-            extractedText = decodedText;
-            documentContentToStore = decodedText;
-          } catch (e) {
-            import_core4.logger.error({ error: e instanceof Error ? e : new Error(String(e)) }, `Failed to decode base64 for ${originalFilename}`);
-            throw new Error(`File ${originalFilename} appears to be corrupted or incorrectly encoded`);
-          }
-        } else {
-          import_core4.logger.debug(`Treating content as plain text for file: ${originalFilename}`);
-          extractedText = content;
-          documentContentToStore = content;
-        }
-      }
-      if (!extractedText || extractedText.trim() === "") {
-        throw new Error(`No text content extracted from ${originalFilename} (type: ${contentType})`);
-      }
-      const documentMemory = createDocumentMemory({
-        text: documentContentToStore,
-        agentId,
-        clientDocumentId,
-        originalFilename,
-        contentType,
-        worldId,
-        fileSize: fileBuffer ? fileBuffer.length : extractedText.length,
-        documentId: clientDocumentId,
-        customMetadata: metadata
-      });
-      const memoryWithScope = {
-        ...documentMemory,
-        id: clientDocumentId,
-        agentId,
-        roomId: roomId || agentId,
-        entityId: entityId || agentId
-      };
-      await this.runtime.createMemory(memoryWithScope, "documents");
-      const fragmentCount = await processFragmentsSynchronously({
-        runtime: this.runtime,
-        documentId: clientDocumentId,
-        fullDocumentText: extractedText,
-        agentId,
-        contentType,
-        roomId: roomId || agentId,
-        entityId: entityId || agentId,
-        worldId: worldId || agentId,
-        documentTitle: originalFilename
-      });
-      import_core4.logger.debug(`"${originalFilename}" stored with ${fragmentCount} fragments`);
-      return {
-        clientDocumentId,
-        storedDocumentMemoryId: memoryWithScope.id,
-        fragmentCount
-      };
-    } catch (error) {
-      import_core4.logger.error({ error }, `Error processing document ${originalFilename}`);
-      throw error;
-    }
-  }
-  async checkExistingKnowledge(knowledgeId) {
-    const existingDocument = await this.runtime.getMemoryById(knowledgeId);
-    return !!existingDocument;
-  }
-  async getKnowledge(message, scope) {
-    if (!message?.content?.text || message?.content?.text.trim().length === 0) {
-      import_core4.logger.warn("Invalid or empty message content for knowledge query");
-      return [];
-    }
-    const embedding = await this.runtime.useModel(import_core4.ModelType.TEXT_EMBEDDING, {
-      text: message.content.text
-    });
-    const filterScope = {};
-    if (scope?.roomId)
-      filterScope.roomId = scope.roomId;
-    if (scope?.worldId)
-      filterScope.worldId = scope.worldId;
-    if (scope?.entityId)
-      filterScope.entityId = scope.entityId;
-    const fragments = await this.runtime.searchMemories({
-      tableName: "knowledge",
-      embedding,
-      query: message.content.text,
-      ...filterScope,
-      count: 20,
-      match_threshold: 0.1
-    });
-    return fragments.filter((fragment) => fragment.id !== undefined).map((fragment) => ({
-      id: fragment.id,
-      content: fragment.content,
-      similarity: fragment.similarity,
-      metadata: fragment.metadata,
-      worldId: fragment.worldId
-    }));
-  }
-  async enrichConversationMemoryWithRAG(memoryId, ragMetadata) {
-    try {
-      const existingMemory = await this.runtime.getMemoryById(memoryId);
-      if (!existingMemory) {
-        import_core4.logger.warn(`Cannot enrich memory ${memoryId} - memory not found`);
-        return;
-      }
-      const ragUsageData = {
-        retrievedFragments: ragMetadata.retrievedFragments,
-        queryText: ragMetadata.queryText,
-        totalFragments: ragMetadata.totalFragments,
-        retrievalTimestamp: ragMetadata.retrievalTimestamp,
-        usedInResponse: true
-      };
-      const updatedMetadata = {
-        ...existingMemory.metadata,
-        knowledgeUsed: true,
-        ragUsage: JSON.stringify(ragUsageData),
-        timestamp: existingMemory.metadata?.timestamp ?? Date.now(),
-        type: import_core4.MemoryType.CUSTOM
-      };
-      await this.runtime.updateMemory({
-        id: memoryId,
-        metadata: updatedMetadata
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      import_core4.logger.warn(`Failed to enrich conversation memory ${memoryId} with RAG data: ${errorMessage}`);
-    }
-  }
-  pendingRAGEnrichment = [];
-  setPendingRAGMetadata(ragMetadata) {
-    const now = Date.now();
-    this.pendingRAGEnrichment = this.pendingRAGEnrichment.filter((entry) => now - entry.timestamp < 30000);
-    this.pendingRAGEnrichment.push({
-      ragMetadata,
-      timestamp: now
-    });
-  }
-  async enrichRecentMemoriesWithPendingRAG() {
-    if (this.pendingRAGEnrichment.length === 0) {
-      return;
-    }
-    try {
-      const recentMemories = await this.runtime.getMemories({
-        tableName: "messages",
-        count: 10
-      });
-      const now = Date.now();
-      const recentConversationMemories = recentMemories.filter((memory) => memory.metadata?.type === "message" && now - (memory.createdAt || 0) < 1e4 && !(memory.metadata && ("ragUsage" in memory.metadata) && memory.metadata.ragUsage)).sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));
-      for (const pendingEntry of this.pendingRAGEnrichment) {
-        const matchingMemory = recentConversationMemories.find((memory) => (memory.createdAt || 0) > pendingEntry.timestamp);
-        if (matchingMemory?.id) {
-          await this.enrichConversationMemoryWithRAG(matchingMemory.id, pendingEntry.ragMetadata);
-          const index = this.pendingRAGEnrichment.indexOf(pendingEntry);
-          if (index > -1) {
-            this.pendingRAGEnrichment.splice(index, 1);
-          }
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      import_core4.logger.warn(`Error enriching recent memories with RAG data: ${errorMessage}`);
-    }
-  }
-  async processCharacterKnowledge(items) {
-    await new Promise((resolve2) => setTimeout(resolve2, 1000));
-    import_core4.logger.info(`Processing ${items.length} character knowledge items`);
-    const processingPromises = items.map(async (item) => {
-      await this.knowledgeProcessingSemaphore.acquire();
-      try {
-        const knowledgeId = generateContentBasedId(item, this.runtime.agentId, {
-          maxChars: 2000,
-          includeFilename: "character-knowledge"
-        });
-        if (await this.checkExistingKnowledge(knowledgeId)) {
-          return;
-        }
-        let metadata = {
-          type: import_core4.MemoryType.CUSTOM,
-          timestamp: Date.now(),
-          source: "character"
-        };
-        const pathMatch = item.match(/^Path: (.+?)(?:\n|\r\n)/);
-        if (pathMatch) {
-          const filePath = pathMatch[1].trim();
-          const extension = filePath.split(".").pop() || "";
-          const filename = filePath.split("/").pop() || "";
-          const title = filename.replace(`.${extension}`, "");
-          metadata = {
-            ...metadata,
-            path: filePath,
-            filename,
-            fileExt: extension,
-            title,
-            fileType: `text/${extension || "plain"}`,
-            fileSize: item.length
-          };
-        }
-        await this._internalAddKnowledge({
-          id: knowledgeId,
-          content: {
-            text: item
-          },
-          metadata
-        }, undefined, {
-          roomId: this.runtime.agentId,
-          entityId: this.runtime.agentId,
-          worldId: this.runtime.agentId
-        });
-      } catch (error) {
-        import_core4.logger.error({ error }, "Error processing character knowledge");
-      } finally {
-        this.knowledgeProcessingSemaphore.release();
-      }
-    });
-    await Promise.all(processingPromises);
-  }
-  async _internalAddKnowledge(item, options = {
-    targetTokens: 1500,
-    overlap: 200,
-    modelContextSize: 4096
-  }, scope = {
-    roomId: this.runtime.agentId,
-    entityId: this.runtime.agentId,
-    worldId: this.runtime.agentId
-  }) {
-    const finalScope = {
-      roomId: scope?.roomId ?? this.runtime.agentId,
-      worldId: scope?.worldId ?? this.runtime.agentId,
-      entityId: scope?.entityId ?? this.runtime.agentId
-    };
-    const documentMetadata = {
-      ...item.metadata ?? {},
-      type: import_core4.MemoryType.CUSTOM,
-      documentId: item.id
-    };
-    const documentMemory = {
-      id: item.id,
-      agentId: this.runtime.agentId,
-      roomId: finalScope.roomId,
-      worldId: finalScope.worldId,
-      entityId: finalScope.entityId,
-      content: item.content,
-      metadata: documentMetadata,
-      createdAt: Date.now()
-    };
-    const existingDocument = await this.runtime.getMemoryById(item.id);
-    if (existingDocument) {
-      await this.runtime.updateMemory({
-        ...documentMemory,
-        id: item.id
-      });
-    } else {
-      await this.runtime.createMemory(documentMemory, "documents");
-    }
-    const fragments = await this.splitAndCreateFragments(item, options.targetTokens, options.overlap, finalScope);
-    for (const fragment of fragments) {
-      try {
-        await this.processDocumentFragment(fragment);
-      } catch (error) {
-        import_core4.logger.error({ error }, `KnowledgeService: Error processing fragment ${fragment.id} for document ${item.id}`);
-      }
-    }
-  }
-  async processDocumentFragment(fragment) {
-    try {
-      await this.runtime.addEmbeddingToMemory(fragment);
-      await this.runtime.createMemory(fragment, "knowledge");
-    } catch (error) {
-      import_core4.logger.error({ error }, `Error processing fragment ${fragment.id}`);
-      throw error;
-    }
-  }
-  async splitAndCreateFragments(document, targetTokens, overlap, scope) {
-    if (!document.content.text) {
-      return [];
-    }
-    const text = document.content.text;
-    const chunks = await import_core4.splitChunks(text, targetTokens, overlap);
-    return chunks.map((chunk, index) => {
-      const fragmentIdContent = `${document.id}-fragment-${index}-${Date.now()}`;
-      const fragmentId = import_core4.createUniqueUuid(this.runtime, fragmentIdContent);
-      return {
-        id: fragmentId,
-        entityId: scope.entityId,
-        agentId: this.runtime.agentId,
-        roomId: scope.roomId,
-        worldId: scope.worldId,
-        content: {
-          text: chunk
-        },
-        metadata: {
-          ...document.metadata || {},
-          type: import_core4.MemoryType.FRAGMENT,
-          documentId: document.id,
-          position: index,
-          timestamp: Date.now()
-        },
-        createdAt: Date.now()
-      };
-    });
-  }
-  async getMemories(params) {
-    return this.runtime.getMemories({
-      ...params,
-      agentId: this.runtime.agentId
-    });
-  }
-  async countMemories(params) {
-    const roomId = params.roomId || this.runtime.agentId;
-    const unique = params.unique ?? false;
-    const tableName = params.tableName;
-    return this.runtime.countMemories(roomId, unique, tableName);
-  }
-  async deleteMemory(memoryId) {
-    await this.runtime.deleteMemory(memoryId);
-  }
-}
-
-// actions.ts
-var processKnowledgeAction = {
-  name: "PROCESS_KNOWLEDGE",
-  description: "Process and store knowledge from a file path or text content into the knowledge base",
-  similes: [],
-  examples: [
-    [
-      {
-        name: "user",
-        content: {
-          text: "Process the document at /path/to/document.pdf"
-        }
-      },
-      {
-        name: "assistant",
-        content: {
-          text: "I'll process the document at /path/to/document.pdf and add it to my knowledge base.",
-          actions: ["PROCESS_KNOWLEDGE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "user",
-        content: {
-          text: "Add this to your knowledge: The capital of France is Paris."
-        }
-      },
-      {
-        name: "assistant",
-        content: {
-          text: "I'll add that information to my knowledge base.",
-          actions: ["PROCESS_KNOWLEDGE"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["process", "knowledge"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegexOk = /\b(?:process|knowledge)\b/i.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, message2, _state) => {
-      const text = message2.content.text?.toLowerCase() || "";
-      const knowledgeKeywords = [
-        "process",
-        "add",
-        "upload",
-        "document",
-        "knowledge",
-        "learn",
-        "remember",
-        "store",
-        "ingest",
-        "file"
-      ];
-      const hasKeyword = knowledgeKeywords.some((keyword) => text.includes(keyword));
-      const pathPattern = /(?:\/[\w.-]+)+|(?:[a-zA-Z]:[\\/][\w\s.-]+(?:[\\/][\w\s.-]+)*)/;
-      const hasPath = pathPattern.test(text);
-      const service = runtime2.getService(KnowledgeService.serviceType);
-      if (!service) {
-        import_core5.logger.warn("Knowledge service not available for PROCESS_KNOWLEDGE action");
-        return false;
-      }
-      return hasKeyword || hasPath;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    try {
-      const service = runtime.getService(KnowledgeService.serviceType);
-      if (!service) {
-        throw new Error("Knowledge service not available");
-      }
-      const text = message.content.text || "";
-      const pathPattern = /(?:\/[\w.-]+)+|(?:[a-zA-Z]:[\\/][\w\s.-]+(?:[\\/][\w\s.-]+)*)/;
-      const pathMatch = text.match(pathPattern);
-      let response;
-      if (pathMatch) {
-        const filePath = pathMatch[0];
-        if (!fs2.existsSync(filePath)) {
-          response = {
-            text: `I couldn't find the file at ${filePath}. Please check the path and try again.`
-          };
-          if (callback) {
-            await callback(response);
-          }
-          return;
-        }
-        const fileBuffer = fs2.readFileSync(filePath);
-        const fileName = path2.basename(filePath);
-        const fileExt = path2.extname(filePath).toLowerCase();
-        let contentType = "text/plain";
-        if (fileExt === ".pdf")
-          contentType = "application/pdf";
-        else if (fileExt === ".docx")
-          contentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
-        else if (fileExt === ".doc")
-          contentType = "application/msword";
-        else if ([".txt", ".md", ".tson", ".xml", ".csv"].includes(fileExt))
-          contentType = "text/plain";
-        const knowledgeOptions = {
-          clientDocumentId: import_core5.stringToUuid(runtime.agentId + fileName + Date.now()),
-          contentType,
-          originalFilename: fileName,
-          worldId: runtime.agentId,
-          content: fileBuffer.toString("base64"),
-          roomId: message.roomId,
-          entityId: message.entityId
-        };
-        const result = await service.addKnowledge(knowledgeOptions);
-        response = {
-          text: `I've successfully processed the document "${fileName}". It has been split into ${result?.fragmentCount || 0} searchable fragments and added to my knowledge base.`
-        };
-      } else {
-        const knowledgeContent = text.replace(/^(add|store|remember|process|learn)\s+(this|that|the following)?:?\s*/i, "").trim();
-        if (!knowledgeContent) {
-          response = {
-            text: "I need some content to add to my knowledge base. Please provide text or a file path."
-          };
-          if (callback) {
-            await callback(response);
-          }
-          return;
-        }
-        const knowledgeOptions = {
-          clientDocumentId: import_core5.stringToUuid(`${runtime.agentId}text${Date.now()}user-knowledge`),
-          contentType: "text/plain",
-          originalFilename: "user-knowledge.txt",
-          worldId: runtime.agentId,
-          content: knowledgeContent,
-          roomId: message.roomId,
-          entityId: message.entityId
-        };
-        await service.addKnowledge(knowledgeOptions);
-        response = {
-          text: `I've added that information to my knowledge base. It has been stored and indexed for future reference.`
-        };
-      }
-      if (callback) {
-        await callback(response);
-      }
-      return { success: true, text: response.text };
-    } catch (error) {
-      import_core5.logger.error({ error }, "Error in PROCESS_KNOWLEDGE action");
-      const errorResponse = {
-        text: `I encountered an error while processing the knowledge: ${error instanceof Error ? error.message : String(error)}`
-      };
-      if (callback) {
-        await callback(errorResponse);
-      }
-      return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
-  }
-};
-var searchKnowledgeAction = {
-  name: "SEARCH_KNOWLEDGE",
-  description: "Search the knowledge base for specific information",
-  similes: [
-    "search knowledge",
-    "find information",
-    "look up",
-    "query knowledge base",
-    "search documents",
-    "find in knowledge"
-  ],
-  examples: [
-    [
-      {
-        name: "user",
-        content: {
-          text: "Search your knowledge for information about quantum computing"
-        }
-      },
-      {
-        name: "assistant",
-        content: {
-          text: "I'll search my knowledge base for information about quantum computing.",
-          actions: ["SEARCH_KNOWLEDGE"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["search", "knowledge"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegexOk = /\b(?:search|knowledge)\b/i.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, message2, _state) => {
-      const text = message2.content.text?.toLowerCase() || "";
-      const searchKeywords = ["search", "find", "look up", "query", "what do you know about"];
-      const knowledgeKeywords = ["knowledge", "information", "document", "database"];
-      const hasSearchKeyword = searchKeywords.some((keyword) => text.includes(keyword));
-      const hasKnowledgeKeyword = knowledgeKeywords.some((keyword) => text.includes(keyword));
-      const service = runtime2.getService(KnowledgeService.serviceType);
-      if (!service) {
-        return false;
-      }
-      return hasSearchKeyword && hasKnowledgeKeyword;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    try {
-      const service = runtime.getService(KnowledgeService.serviceType);
-      if (!service) {
-        throw new Error("Knowledge service not available");
-      }
-      const text = message.content.text || "";
-      const query = text.replace(/^(search|find|look up|query)\s+(your\s+)?knowledge\s+(base\s+)?(for\s+)?/i, "").trim();
-      if (!query) {
-        const response2 = {
-          text: "What would you like me to search for in my knowledge base?"
-        };
-        if (callback) {
-          await callback(response2);
-        }
-        return;
-      }
-      const searchMessage = {
-        ...message,
-        content: {
-          text: query
-        }
-      };
-      const results = await service.getKnowledge(searchMessage);
-      let response;
-      if (results.length === 0) {
-        response = {
-          text: `I couldn't find any information about "${query}" in my knowledge base.`
-        };
-      } else {
-        const formattedResults = results.slice(0, 3).map((item, index) => `${index + 1}. ${item.content.text}`).join(`
-
-`);
-        response = {
-          text: `Here's what I found about "${query}":
-
-${formattedResults}`
-        };
-      }
-      if (callback) {
-        await callback(response);
-      }
-      return { success: true, text: response.text };
-    } catch (error) {
-      import_core5.logger.error({ error }, "Error in SEARCH_KNOWLEDGE action");
-      const errorResponse = {
-        text: `I encountered an error while searching the knowledge base: ${error instanceof Error ? error.message : String(error)}`
-      };
-      if (callback) {
-        await callback(errorResponse);
-      }
-      return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
-  }
-};
-var knowledgeActions = [processKnowledgeAction, searchKnowledgeAction];
-
-// documents-provider.ts
-var import_core6 = require("@elizaos/core");
-var documentsProvider = {
-  name: "AVAILABLE_DOCUMENTS",
-  description: "List of documents available in the knowledge base. Shows which documents the agent can reference and retrieve information from.",
-  dynamic: true,
-  get: async (runtime, _message, _state) => {
-    try {
-      const knowledgeService = runtime.getService("knowledge");
-      if (!knowledgeService) {
-        import_core6.logger.warn("Knowledge service not available for documents provider");
-        return {
-          data: { documents: [] },
-          values: {
-            documentsCount: 0,
-            documents: "",
-            availableDocuments: ""
-          },
-          text: ""
-        };
-      }
-      const allMemories = await knowledgeService.getMemories({
-        tableName: "documents",
-        roomId: runtime.agentId,
-        count: 100
-      });
-      const documents = allMemories.filter((memory) => memory.metadata?.type === import_core6.MemoryType.DOCUMENT);
-      if (!documents || documents.length === 0) {
-        return {
-          data: { documents: [] },
-          values: {
-            documentsCount: 0,
-            documents: "",
-            availableDocuments: ""
-          },
-          text: ""
-        };
-      }
-      const documentsList = documents.map((doc, index) => {
-        const metadata = doc.metadata;
-        const filename = metadata?.filename || metadata?.title || `Document ${index + 1}`;
-        const fileType = metadata?.fileExt || metadata?.fileType || "";
-        const source = metadata?.source || "upload";
-        const fileSize = metadata?.fileSize;
-        const parts = [filename];
-        if (fileType) {
-          parts.push(fileType);
-        }
-        if (fileSize) {
-          const sizeKB = Math.round(fileSize / 1024);
-          if (sizeKB > 1024) {
-            parts.push(`${Math.round(sizeKB / 1024)}MB`);
-          } else {
-            parts.push(`${sizeKB}KB`);
-          }
-        }
-        if (source && source !== "upload") {
-          parts.push(`from ${source}`);
-        }
-        return parts.join(" - ");
-      }).join(`
-`);
-      const documentsText = import_core6.addHeader("# Available Documents", `${documents.length} document(s) in knowledge base:
-${documentsList}`);
-      return {
-        data: {
-          documents: documents.map((doc) => ({
-            id: doc.id,
-            filename: doc.metadata?.filename || doc.metadata?.title,
-            fileType: doc.metadata?.fileType || doc.metadata?.fileExt,
-            source: doc.metadata?.source
-          })),
-          count: documents.length
-        },
-        values: {
-          documentsCount: documents.length,
-          documents: documentsList,
-          availableDocuments: documentsText
-        },
-        text: documentsText
-      };
-    } catch (error) {
-      import_core6.logger.error("Error in documents provider:", error instanceof Error ? error.message : String(error));
-      return {
-        data: { documents: [], error: error instanceof Error ? error.message : String(error) },
-        values: {
-          documentsCount: 0,
-          documents: "",
-          availableDocuments: ""
-        },
-        text: ""
-      };
-    }
-  }
-};
-
-// provider.ts
-var import_core7 = require("@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.",
-  dynamic: true,
-  get: async (runtime, message) => {
-    const knowledgeService = runtime.getService("knowledge");
-    const knowledgeData = await knowledgeService?.getKnowledge(message);
-    if (!knowledgeData || knowledgeData.length === 0) {
-      return {
-        text: "",
-        values: { knowledge: "", knowledgeUsed: false },
-        data: { knowledge: "", ragMetadata: null, knowledgeUsed: false }
-      };
-    }
-    const firstFiveKnowledgeItems = knowledgeData.slice(0, 5);
-    let knowledge = import_core7.addHeader("# Knowledge", firstFiveKnowledgeItems.map((item) => `- ${item.content.text}`).join(`
-`));
-    const tokenLength = 3.5;
-    const maxChars = 4000 * tokenLength;
-    if (knowledge.length > maxChars) {
-      knowledge = knowledge.slice(0, maxChars);
+var import_multer = __toESM(require("multer"));
+
+// utils.ts
+var import_node_buffer = require("node:buffer");
+var mammoth = __toESM(require("mammoth"));
+var import_unpdf = require("unpdf");
+var MAX_FALLBACK_SIZE_BYTES = 5 * 1024 * 1024;
+function normalizeS3Url(url) {
+  try {
+    const urlObj = new URL(url);
+    return `${urlObj.origin}${urlObj.pathname}`;
+  } catch {
+    return url;
+  }
+}
+async function fetchUrlContent(url) {
+  try {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    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 ragMetadata = {
-      retrievedFragments: knowledgeData.map((fragment) => {
-        const fragmentMetadata = fragment.metadata;
-        return {
-          fragmentId: fragment.id,
-          documentTitle: fragmentMetadata?.filename || fragmentMetadata?.title || "",
-          similarityScore: fragment.similarity,
-          contentPreview: `${(fragment.content?.text || "").substring(0, 100)}...`
-        };
-      }),
-      queryText: message.content?.text || "",
-      totalFragments: knowledgeData.length,
-      retrievalTimestamp: Date.now()
-    };
-    knowledgeService.setPendingRAGMetadata(ragMetadata);
-    setTimeout(async () => {
-      await knowledgeService.enrichRecentMemoriesWithPendingRAG();
-    }, 2000);
+    const contentType = response.headers.get("content-type") || "application/octet-stream";
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = import_node_buffer.Buffer.from(arrayBuffer);
+    const base64Content = buffer.toString("base64");
     return {
-      data: {
-        knowledge,
-        ragMetadata,
-        knowledgeUsed: true
-      },
-      values: {
-        knowledge,
-        knowledgeUsed: true
-      },
-      text: knowledge,
-      ragMetadata,
-      knowledgeUsed: true
+      content: base64Content,
+      contentType
     };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to fetch content from URL: ${errorMessage}`);
   }
-};
+}
 
 // routes.ts
-var import_node_fs = __toESM(require("node:fs"));
-var import_node_path = __toESM(require("node:path"));
-var import_core8 = require("@elizaos/core");
-var import_multer = __toESM(require("multer"));
 function asWritableStream(res) {
   return res;
 }
@@ -2980,7 +173,7 @@ var cleanupFile = (filePath) => {
     try {
       import_node_fs.default.unlinkSync(filePath);
     } catch (error) {
-      import_core8.logger.error({ error }, `Error cleaning up file ${filePath}`);
+      import_core.logger.error({ error }, `Error cleaning up file ${filePath}`);
     }
   }
 };
@@ -2992,7 +185,7 @@ var cleanupFiles = (files) => {
   }
 };
 async function uploadKnowledgeHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
@@ -3009,15 +202,15 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const invalidFiles = files.filter((file) => {
         if (file.size === 0) {
-          import_core8.logger.warn(`File ${file.originalname} is empty`);
+          import_core.logger.warn(`File ${file.originalname} is empty`);
           return true;
         }
         if (!file.originalname || file.originalname.trim() === "") {
-          import_core8.logger.warn(`File has no name`);
+          import_core.logger.warn(`File has no name`);
           return true;
         }
         if (!file.path) {
-          import_core8.logger.warn(`File ${file.originalname} has no path`);
+          import_core.logger.warn(`File ${file.originalname} has no path`);
           return true;
         }
         return false;
@@ -3029,11 +222,11 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const agentId = req.body?.agentId || req.query?.agentId;
       if (!agentId) {
-        import_core8.logger.error("No agent ID provided in upload request");
+        import_core.logger.error("No agent ID provided in upload request");
         return sendError(res, 400, "MISSING_AGENT_ID", "Agent ID is required for uploading knowledge");
       }
       const worldId = req.body?.worldId || agentId;
-      import_core8.logger.info(`Processing file upload for agent: ${agentId}`);
+      import_core.logger.info(`Processing file upload for agent: ${agentId}`);
       const processingPromises = files.map(async (file) => {
         const originalFilename = file.originalname;
         const filePath = file.path;
@@ -3061,7 +254,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             status: "success"
           };
         } catch (fileError) {
-          import_core8.logger.error(`Error processing file ${file.originalname}: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+          import_core.logger.error(`Error processing file ${file.originalname}: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
           cleanupFile(filePath);
           return {
             id: "",
@@ -3080,7 +273,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       }
       const agentId = req.body?.agentId || req.query?.agentId;
       if (!agentId) {
-        import_core8.logger.error("No agent ID provided in URL request");
+        import_core.logger.error("No agent ID provided in URL request");
         return sendError(res, 400, "MISSING_AGENT_ID", "Agent ID is required for uploading knowledge from URLs");
       }
       const processingPromises = fileUrls.map(async (fileUrl) => {
@@ -3090,7 +283,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
           const pathSegments = urlObject.pathname.split("/");
           const encodedFilename = pathSegments[pathSegments.length - 1] || "document.pdf";
           const originalFilename = decodeURIComponent(encodedFilename);
-          import_core8.logger.debug(`Fetching content from URL: ${fileUrl}`);
+          import_core.logger.debug(`Fetching content from URL: ${fileUrl}`);
           const { content, contentType: fetchedContentType } = await fetchUrlContent(fileUrl);
           let contentType = fetchedContentType;
           if (contentType === "application/octet-stream") {
@@ -3137,7 +330,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
             status: "success"
           };
         } catch (urlError) {
-          import_core8.logger.error(`Error processing URL ${fileUrl}: ${urlError instanceof Error ? urlError.message : String(urlError)}`);
+          import_core.logger.error(`Error processing URL ${fileUrl}: ${urlError instanceof Error ? urlError.message : String(urlError)}`);
           return {
             fileUrl,
             status: "error_processing",
@@ -3149,7 +342,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
       sendSuccess(res, results);
     }
   } catch (error) {
-    import_core8.logger.error({ error }, "Error processing knowledge");
+    import_core.logger.error({ error }, "Error processing knowledge");
     if (hasUploadedFiles) {
       cleanupFiles(req.files);
     }
@@ -3157,7 +350,7 @@ async function uploadKnowledgeHandler(req, res, runtime) {
   }
 }
 async function getKnowledgeDocumentsHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found for getKnowledgeDocumentsHandler");
   }
@@ -3174,7 +367,7 @@ async function getKnowledgeDocumentsHandler(req, res, runtime) {
     let filteredMemories = memories;
     if (fileUrls && fileUrls.length > 0) {
       const normalizedRequestUrls = fileUrls.map((url) => normalizeS3Url(String(url)));
-      const urlBasedIds = normalizedRequestUrls.map((url) => import_core8.createUniqueUuid(runtime, url));
+      const urlBasedIds = normalizedRequestUrls.map((url) => import_core.createUniqueUuid(runtime, url));
       filteredMemories = memories.filter((memory) => urlBasedIds.includes(memory.id) || memory.metadata && ("url" in memory.metadata) && typeof memory.metadata.url === "string" && normalizedRequestUrls.includes(normalizeS3Url(memory.metadata.url)));
     }
     const cleanMemories = includeEmbedding ? filteredMemories : filteredMemories.map((memory) => ({
@@ -3188,42 +381,42 @@ async function getKnowledgeDocumentsHandler(req, res, runtime) {
       totalRequested: fileUrls ? fileUrls.length : 0
     });
   } catch (error) {
-    import_core8.logger.error({ error }, "Error retrieving documents");
+    import_core.logger.error({ error }, "Error retrieving documents");
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve documents", error instanceof Error ? error.message : String(error));
   }
 }
 async function deleteKnowledgeDocumentHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found for deleteKnowledgeDocumentHandler");
   }
   const knowledgeId = req.params?.knowledgeId;
   if (!knowledgeId || knowledgeId.length < 36) {
-    import_core8.logger.error(`Invalid knowledge ID format: ${knowledgeId}`);
+    import_core.logger.error(`Invalid knowledge ID format: ${knowledgeId}`);
     return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
   }
   try {
     const typedKnowledgeId = knowledgeId;
-    import_core8.logger.debug(`Deleting document: ${typedKnowledgeId}`);
+    import_core.logger.debug(`Deleting document: ${typedKnowledgeId}`);
     await service.deleteMemory(typedKnowledgeId);
     sendSuccess(res, null, 204);
   } catch (error) {
-    import_core8.logger.error({ error }, `Error deleting document ${knowledgeId}`);
+    import_core.logger.error({ error }, `Error deleting document ${knowledgeId}`);
     sendError(res, 500, "DELETE_ERROR", "Failed to delete document", error instanceof Error ? error.message : String(error));
   }
 }
 async function getKnowledgeByIdHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found for getKnowledgeByIdHandler");
   }
   const knowledgeId = req.params?.knowledgeId;
   if (!knowledgeId || knowledgeId.length < 36) {
-    import_core8.logger.error(`Invalid knowledge ID format: ${knowledgeId}`);
+    import_core.logger.error(`Invalid knowledge ID format: ${knowledgeId}`);
     return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
   }
   try {
-    import_core8.logger.debug(`Retrieving document: ${knowledgeId}`);
+    import_core.logger.debug(`Retrieving document: ${knowledgeId}`);
     const memories = await service.getMemories({
       tableName: "documents",
       count: 1e4
@@ -3239,7 +432,7 @@ async function getKnowledgeByIdHandler(req, res, runtime) {
     };
     sendSuccess(res, { document: cleanDocument });
   } catch (error) {
-    import_core8.logger.error({ error }, `Error retrieving document ${knowledgeId}`);
+    import_core.logger.error({ error }, `Error retrieving document ${knowledgeId}`);
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve document", error instanceof Error ? error.message : String(error));
   }
 }
@@ -3248,7 +441,7 @@ async function knowledgePanelHandler(req, res, runtime) {
   const requestPath = req.originalUrl || req.url || req.path || "";
   const pluginBasePath = requestPath.replace(/\/display.*$/, "");
   try {
-    const currentDir = import_node_path.default.dirname(new URL("file:///Users/shawwalters/eliza-workspace/plugins/plugin-knowledge/typescript/routes.ts").pathname);
+    const currentDir = import_node_path.default.dirname(new URL("file:///Users/shawwalters/eliza-workspace/milady/plugins/plugin-knowledge/typescript/routes.ts").pathname);
     const frontendPath = import_node_path.default.join(currentDir, "../dist/index.html");
     if (import_node_fs.default.existsSync(frontendPath)) {
       const html = await import_node_fs.default.promises.readFile(frontendPath, "utf8");
@@ -3317,14 +510,14 @@ async function knowledgePanelHandler(req, res, runtime) {
       res.end(html);
     }
   } catch (error) {
-    import_core8.logger.error({ error }, "Error serving frontend");
+    import_core.logger.error({ error }, "Error serving frontend");
     sendError(res, 500, "FRONTEND_ERROR", "Failed to load knowledge panel", error instanceof Error ? error.message : String(error));
   }
 }
 async function frontendAssetHandler(req, res, _runtime) {
   try {
     const fullPath = req.originalUrl || req.url || req.path || "";
-    const currentDir = import_node_path.default.dirname(new URL("file:///Users/shawwalters/eliza-workspace/plugins/plugin-knowledge/typescript/routes.ts").pathname);
+    const currentDir = import_node_path.default.dirname(new URL("file:///Users/shawwalters/eliza-workspace/milady/plugins/plugin-knowledge/typescript/routes.ts").pathname);
     const assetsMarker = "/assets/";
     const assetsStartIndex = fullPath.lastIndexOf(assetsMarker);
     let assetName = null;
@@ -3353,12 +546,12 @@ async function frontendAssetHandler(req, res, _runtime) {
       sendError(res, 404, "NOT_FOUND", `Asset not found: ${req.url}`);
     }
   } catch (error) {
-    import_core8.logger.error({ error }, `Error serving asset ${req.url}`);
+    import_core.logger.error({ error }, `Error serving asset ${req.url}`);
     sendError(res, 500, "ASSET_ERROR", `Failed to load asset ${req.url}`, error instanceof Error ? error.message : String(error));
   }
 }
 async function getKnowledgeChunksHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
@@ -3412,12 +605,12 @@ async function getKnowledgeChunksHandler(req, res, runtime) {
       }
     });
   } catch (error) {
-    import_core8.logger.error({ error }, "Error retrieving chunks");
+    import_core.logger.error({ error }, "Error retrieving chunks");
     sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve knowledge chunks", error instanceof Error ? error.message : String(error));
   }
 }
 async function searchKnowledgeHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
@@ -3433,7 +626,7 @@ async function searchKnowledgeHandler(req, res, runtime) {
     if (!searchText || searchText.trim().length === 0) {
       return sendError(res, 400, "INVALID_QUERY", "Search query cannot be empty");
     }
-    const embedding = await runtime.useModel(import_core8.ModelType.TEXT_EMBEDDING, {
+    const embedding = await runtime.useModel(import_core.ModelType.TEXT_EMBEDDING, {
       text: searchText
     });
     const results = await runtime.searchMemories({
@@ -3476,12 +669,12 @@ async function searchKnowledgeHandler(req, res, runtime) {
       count: enhancedResults.length
     });
   } catch (error) {
-    import_core8.logger.error({ error }, "Error searching knowledge");
+    import_core.logger.error({ error }, "Error searching knowledge");
     sendError(res, 500, "SEARCH_ERROR", "Failed to search knowledge", error instanceof Error ? error.message : String(error));
   }
 }
 async function getGraphNodesHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
@@ -3510,7 +703,7 @@ async function getGraphNodesHandler(req, res, runtime) {
     const links = [];
     paginatedDocuments.forEach((doc) => {
       if (!doc.id) {
-        import_core8.logger.warn("Skipping document without ID");
+        import_core.logger.warn("Skipping document without ID");
         return;
       }
       nodes.push({ id: doc.id, type: "document" });
@@ -3528,7 +721,7 @@ async function getGraphNodesHandler(req, res, runtime) {
         const docFragments = allFragments.filter((fragment) => {
           const metadata = fragment.metadata;
           const typeString = typeof metadata?.type === "string" ? metadata.type : null;
-          const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === import_core8.MemoryType.FRAGMENT || !metadata?.type && metadata?.documentId;
+          const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === import_core.MemoryType.FRAGMENT || !metadata?.type && metadata?.documentId;
           return metadata?.documentId === doc.id && isFragment;
         });
         docFragments.forEach((frag) => {
@@ -3552,12 +745,12 @@ async function getGraphNodesHandler(req, res, runtime) {
       }
     });
   } catch (error) {
-    import_core8.logger.error({ error }, "Error fetching graph nodes");
+    import_core.logger.error({ error }, "Error fetching graph nodes");
     sendError(res, 500, "GRAPH_ERROR", "Failed to fetch graph nodes", error instanceof Error ? error.message : String(error));
   }
 }
 async function getGraphNodeDetailsHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
@@ -3611,15 +804,15 @@ async function getGraphNodeDetailsHandler(req, res, runtime) {
       });
       return;
     }
-    import_core8.logger.error(`Node ${nodeId} not found`);
+    import_core.logger.error(`Node ${nodeId} not found`);
     sendError(res, 404, "NOT_FOUND", `Node with ID ${nodeId} not found`);
   } catch (error) {
-    import_core8.logger.error({ error }, `Error fetching node details for ${nodeId}`);
+    import_core.logger.error({ error }, `Error fetching node details for ${nodeId}`);
     sendError(res, 500, "GRAPH_ERROR", "Failed to fetch node details", error instanceof Error ? error.message : String(error));
   }
 }
 async function expandDocumentGraphHandler(req, res, runtime) {
-  const service = runtime.getService(KnowledgeService.serviceType);
+  const service = runtime.getService(import_core.KnowledgeService.serviceType);
   if (!service) {
     return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
   }
@@ -3637,7 +830,7 @@ async function expandDocumentGraphHandler(req, res, runtime) {
     const documentFragments = allFragments.filter((fragment) => {
       const metadata = fragment.metadata;
       const typeString = typeof metadata?.type === "string" ? metadata.type : null;
-      const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === import_core8.MemoryType.FRAGMENT || !metadata?.type && metadata?.documentId;
+      const isFragment = typeString && typeString.toLowerCase() === "fragment" || metadata?.type === import_core.MemoryType.FRAGMENT || !metadata?.type && metadata?.documentId;
       return metadata?.documentId === documentId && isFragment;
     });
     const nodes = documentFragments.filter((frag) => frag.id !== undefined).map((frag) => ({
@@ -3655,7 +848,7 @@ async function expandDocumentGraphHandler(req, res, runtime) {
       fragmentCount: nodes.length
     });
   } catch (error) {
-    import_core8.logger.error({ error }, `Error expanding document ${documentId}`);
+    import_core.logger.error({ error }, `Error expanding document ${documentId}`);
     sendError(res, 500, "GRAPH_ERROR", "Failed to expand document", error instanceof Error ? error.message : String(error));
   }
 }
@@ -3664,7 +857,7 @@ async function uploadKnowledgeWithMulter(req, res, runtime) {
   const uploadArray = upload.array("files", parseInt(String(runtime.getSetting("KNOWLEDGE_MAX_FILES") || "10"), 10));
   uploadArray(req, res, (err) => {
     if (err) {
-      import_core8.logger.error({ error: err }, "File upload error");
+      import_core.logger.error({ error: err }, "File upload error");
       return sendError(res, 400, "UPLOAD_ERROR", err.message);
     }
     uploadKnowledgeHandler(req, res, runtime);
@@ -3733,22 +926,205 @@ var knowledgeRoutes = [
   }
 ];
 
+// index.ts
+var import_core5 = require("@elizaos/core");
+
+// documents-provider.ts
+var import_core2 = require("@elizaos/core");
+var documentsProvider = {
+  name: "AVAILABLE_DOCUMENTS",
+  description: "List of documents available in the knowledge base. Shows which documents the agent can reference and retrieve information from.",
+  dynamic: true,
+  get: async (runtime, _message, _state) => {
+    try {
+      const knowledgeService = runtime.getService("knowledge");
+      if (!knowledgeService) {
+        import_core2.logger.warn("Knowledge service not available for documents provider");
+        return {
+          data: { documents: [] },
+          values: {
+            documentsCount: 0,
+            documents: "",
+            availableDocuments: ""
+          },
+          text: ""
+        };
+      }
+      const allMemories = await knowledgeService.getMemories({
+        tableName: "documents",
+        roomId: runtime.agentId,
+        count: 100
+      });
+      const documents = allMemories.filter((memory) => memory.metadata?.type === import_core2.MemoryType.DOCUMENT);
+      if (!documents || documents.length === 0) {
+        return {
+          data: { documents: [] },
+          values: {
+            documentsCount: 0,
+            documents: "",
+            availableDocuments: ""
+          },
+          text: ""
+        };
+      }
+      const documentsList = documents.map((doc, index) => {
+        const metadata = doc.metadata;
+        const filename = metadata?.filename || metadata?.title || `Document ${index + 1}`;
+        const fileType = metadata?.fileExt || metadata?.fileType || "";
+        const source = metadata?.source || "upload";
+        const fileSize = metadata?.fileSize;
+        const parts = [filename];
+        if (fileType) {
+          parts.push(fileType);
+        }
+        if (fileSize) {
+          const sizeKB = Math.round(fileSize / 1024);
+          if (sizeKB > 1024) {
+            parts.push(`${Math.round(sizeKB / 1024)}MB`);
+          } else {
+            parts.push(`${sizeKB}KB`);
+          }
+        }
+        if (source && source !== "upload") {
+          parts.push(`from ${source}`);
+        }
+        return parts.join(" - ");
+      }).join(`
+`);
+      const documentsText = import_core2.addHeader("# Available Documents", `${documents.length} document(s) in knowledge base:
+${documentsList}`);
+      return {
+        data: {
+          documents: documents.map((doc) => ({
+            id: doc.id,
+            filename: doc.metadata?.filename || doc.metadata?.title,
+            fileType: doc.metadata?.fileType || doc.metadata?.fileExt,
+            source: doc.metadata?.source
+          })),
+          count: documents.length
+        },
+        values: {
+          documentsCount: documents.length,
+          documents: documentsList,
+          availableDocuments: documentsText
+        },
+        text: documentsText
+      };
+    } catch (error) {
+      import_core2.logger.error("Error in documents provider:", error instanceof Error ? error.message : String(error));
+      return {
+        data: { documents: [], error: error instanceof Error ? error.message : String(error) },
+        values: {
+          documentsCount: 0,
+          documents: "",
+          availableDocuments: ""
+        },
+        text: ""
+      };
+    }
+  }
+};
+// provider.ts
+var import_core3 = require("@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.",
+  dynamic: true,
+  get: async (runtime, message) => {
+    const knowledgeService = runtime.getService("knowledge");
+    const knowledgeData = await knowledgeService?.getKnowledge(message);
+    if (!knowledgeData || knowledgeData.length === 0) {
+      return {
+        text: "",
+        values: { knowledge: "", knowledgeUsed: false },
+        data: { knowledge: "", ragMetadata: null, knowledgeUsed: false }
+      };
+    }
+    const firstFiveKnowledgeItems = knowledgeData.slice(0, 5);
+    let knowledge = import_core3.addHeader("# Knowledge", firstFiveKnowledgeItems.map((item) => `- ${item.content.text}`).join(`
+`));
+    const tokenLength = 3.5;
+    const maxChars = 4000 * tokenLength;
+    if (knowledge.length > maxChars) {
+      knowledge = knowledge.slice(0, maxChars);
+    }
+    const ragMetadata = {
+      retrievedFragments: knowledgeData.map((fragment) => {
+        const fragmentMetadata = fragment.metadata;
+        return {
+          fragmentId: fragment.id,
+          documentTitle: fragmentMetadata?.filename || fragmentMetadata?.title || "",
+          similarityScore: fragment.similarity,
+          contentPreview: `${(fragment.content?.text || "").substring(0, 100)}...`
+        };
+      }),
+      queryText: message.content?.text || "",
+      totalFragments: knowledgeData.length,
+      retrievalTimestamp: Date.now()
+    };
+    knowledgeService.setPendingRAGMetadata(ragMetadata);
+    setTimeout(async () => {
+      await knowledgeService.enrichRecentMemoriesWithPendingRAG();
+    }, 2000);
+    return {
+      data: {
+        knowledge,
+        ragMetadata,
+        knowledgeUsed: true
+      },
+      values: {
+        knowledge,
+        knowledgeUsed: true
+      },
+      text: knowledge,
+      ragMetadata,
+      knowledgeUsed: true
+    };
+  }
+};
+// types.ts
+var import_zod = __toESM(require("zod"));
+var ModelConfigSchema = import_zod.default.object({
+  EMBEDDING_PROVIDER: import_zod.default.enum(["local", "openai", "google"]).optional(),
+  TEXT_PROVIDER: import_zod.default.enum(["openai", "anthropic", "openrouter", "google"]).optional(),
+  OPENAI_API_KEY: import_zod.default.string().optional(),
+  ANTHROPIC_API_KEY: import_zod.default.string().optional(),
+  OPENROUTER_API_KEY: import_zod.default.string().optional(),
+  GOOGLE_API_KEY: import_zod.default.string().optional(),
+  OPENAI_BASE_URL: import_zod.default.string().optional(),
+  ANTHROPIC_BASE_URL: import_zod.default.string().optional(),
+  OPENROUTER_BASE_URL: import_zod.default.string().optional(),
+  GOOGLE_BASE_URL: import_zod.default.string().optional(),
+  TEXT_EMBEDDING_MODEL: import_zod.default.string(),
+  TEXT_MODEL: import_zod.default.string().optional(),
+  MAX_INPUT_TOKENS: import_zod.default.string().or(import_zod.default.number()).transform((val) => typeof val === "string" ? parseInt(val, 10) : val),
+  MAX_OUTPUT_TOKENS: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 4096),
+  EMBEDDING_DIMENSION: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 1536),
+  LOAD_DOCS_ON_STARTUP: import_zod.default.boolean().default(false),
+  CTX_KNOWLEDGE_ENABLED: import_zod.default.boolean().default(false),
+  RATE_LIMIT_ENABLED: import_zod.default.boolean().default(true),
+  MAX_CONCURRENT_REQUESTS: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 150),
+  REQUESTS_PER_MINUTE: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 300),
+  TOKENS_PER_MINUTE: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 750000),
+  BATCH_DELAY_MS: import_zod.default.string().or(import_zod.default.number()).optional().transform((val) => val ? typeof val === "string" ? parseInt(val, 10) : val : 100)
+});
+var KnowledgeServiceType = {
+  KNOWLEDGE: "knowledge"
+};
+
 // index.ts
 function createKnowledgePlugin(config = {}) {
-  const { enableUI = true, enableRoutes = true, enableActions = true, enableTests = true } = config;
-  const plugin = {
-    name: "knowledge",
-    description: "Plugin for Retrieval Augmented Generation, including knowledge management and embedding.",
-    services: [KnowledgeService],
-    providers: [knowledgeProvider, documentsProvider]
-  };
+  const { enableUI = true, enableRoutes = true, enableActions = true } = config;
+  const plugin = import_core4.createKnowledgePlugin({
+    enableActions,
+    enableProviders: true
+  });
+  if (!enableActions) {
+    plugin.actions = undefined;
+  }
   if (enableUI || enableRoutes) {
     plugin.routes = knowledgeRoutes;
   }
-  if (enableActions) {
-    plugin.actions = knowledgeActions;
-  }
-  if (enableTests) {}
   return plugin;
 }
 var knowledgePluginCore = createKnowledgePlugin({
@@ -3767,8 +1143,8 @@ var knowledgePlugin = createKnowledgePlugin({
   enableUI: true,
   enableRoutes: true,
   enableActions: true,
-  enableTests: true
+  enableTests: false
 });
 
-//# debugId=AEF1BFD61156963C64756E2164756E21
+//# debugId=51A9920C1D88785B64756E2164756E21
 //# sourceMappingURL=index.node.cjs.map