@elizaos/plugin-knowledge 2.0.0-alpha.5 → 2.0.0-alpha.6

package/dist/cjs/index.node.cjs

@@ -0,0 +1,3756 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// index.node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  knowledgeProvider: () => knowledgeProvider,
+  knowledgePluginHeadless: () => knowledgePluginHeadless,
+  knowledgePluginCore: () => knowledgePluginCore,
+  knowledgePlugin: () => knowledgePlugin,
+  documentsProvider: () => documentsProvider,
+  createKnowledgePlugin: () => createKnowledgePlugin,
+  ModelConfigSchema: () => ModelConfigSchema,
+  KnowledgeServiceType: () => KnowledgeServiceType,
+  KnowledgeService: () => 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
+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"));
+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/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/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/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/rng.js
+var import_node_crypto = require("node:crypto");
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_node_crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// 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/native.js
+var import_node_crypto2 = require("node:crypto");
+var native_default = { randomUUID: import_node_crypto2.randomUUID };
+
+// 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/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 __avRegex = /\b(?:process|knowledge)\b/i;
+    const __avRegexOk = __avRegex.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 __avRegex = /\b(?:search|knowledge)\b/i;
+    const __avRegexOk = __avRegex.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);
+    }
+    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
+    };
+  }
+};
+
+// 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;
+}
+var createUploadMiddleware = (runtime) => {
+  const uploadDir = String(runtime.getSetting("KNOWLEDGE_UPLOAD_DIR") || "/tmp/uploads/");
+  const maxFileSize = parseInt(String(runtime.getSetting("KNOWLEDGE_MAX_FILE_SIZE") || "52428800"), 10);
+  const maxFiles = parseInt(String(runtime.getSetting("KNOWLEDGE_MAX_FILES") || "10"), 10);
+  const allowedMimeTypes = String(runtime.getSetting("KNOWLEDGE_ALLOWED_MIME_TYPES") || "").split(",").filter(Boolean).length > 0 ? String(runtime.getSetting("KNOWLEDGE_ALLOWED_MIME_TYPES") || "").split(",") : [
+    "text/plain",
+    "text/markdown",
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "text/html",
+    "application/json",
+    "application/xml",
+    "text/csv"
+  ];
+  return import_multer.default({
+    dest: uploadDir,
+    limits: {
+      fileSize: maxFileSize,
+      files: maxFiles
+    },
+    fileFilter: (_req, file, cb) => {
+      if (allowedMimeTypes.includes(file.mimetype)) {
+        cb(null, true);
+      } else {
+        cb(new Error(`File type ${file.mimetype} not allowed. Allowed types: ${allowedMimeTypes.join(", ")}`));
+      }
+    }
+  });
+};
+function sendSuccess(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ success: true, data }));
+}
+function sendError(res, status, code, message, details) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ success: false, error: { code, message, details } }));
+}
+var cleanupFile = (filePath) => {
+  if (filePath && import_node_fs.default.existsSync(filePath)) {
+    try {
+      import_node_fs.default.unlinkSync(filePath);
+    } catch (error) {
+      import_core8.logger.error({ error }, `Error cleaning up file ${filePath}`);
+    }
+  }
+};
+var cleanupFiles = (files) => {
+  if (files) {
+    files.forEach((file) => {
+      cleanupFile(file.path);
+    });
+  }
+};
+async function uploadKnowledgeHandler(req, res, runtime) {
+  const service = runtime.getService(KnowledgeService.serviceType);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
+  }
+  const hasUploadedFiles = req.files && req.files.length > 0;
+  const isJsonRequest = !hasUploadedFiles && req.body && (req.body.fileUrl || req.body.fileUrls);
+  if (!hasUploadedFiles && !isJsonRequest) {
+    return sendError(res, 400, "INVALID_REQUEST", "Request must contain either files or URLs");
+  }
+  try {
+    if (hasUploadedFiles) {
+      const files = req.files;
+      if (!files || files.length === 0) {
+        return sendError(res, 400, "NO_FILES", "No files uploaded");
+      }
+      const invalidFiles = files.filter((file) => {
+        if (file.size === 0) {
+          import_core8.logger.warn(`File ${file.originalname} is empty`);
+          return true;
+        }
+        if (!file.originalname || file.originalname.trim() === "") {
+          import_core8.logger.warn(`File has no name`);
+          return true;
+        }
+        if (!file.path) {
+          import_core8.logger.warn(`File ${file.originalname} has no path`);
+          return true;
+        }
+        return false;
+      });
+      if (invalidFiles.length > 0) {
+        cleanupFiles(files);
+        const invalidFileNames = invalidFiles.map((f) => f.originalname || "unnamed").join(", ");
+        return sendError(res, 400, "INVALID_FILES", `Invalid or corrupted files: ${invalidFileNames}`);
+      }
+      const agentId = req.body?.agentId || req.query?.agentId;
+      if (!agentId) {
+        import_core8.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}`);
+      const processingPromises = files.map(async (file) => {
+        const originalFilename = file.originalname;
+        const filePath = file.path;
+        try {
+          const fileBuffer = await import_node_fs.default.promises.readFile(filePath);
+          const base64Content = fileBuffer.toString("base64");
+          const addKnowledgeOpts = {
+            agentId,
+            clientDocumentId: "",
+            contentType: file.mimetype,
+            originalFilename,
+            content: base64Content,
+            worldId,
+            roomId: agentId,
+            entityId: agentId
+          };
+          const result = await service.addKnowledge(addKnowledgeOpts);
+          cleanupFile(filePath);
+          return {
+            id: result.clientDocumentId,
+            filename: originalFilename,
+            type: file.mimetype,
+            size: file.size,
+            uploadedAt: Date.now(),
+            status: "success"
+          };
+        } catch (fileError) {
+          import_core8.logger.error(`Error processing file ${file.originalname}: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+          cleanupFile(filePath);
+          return {
+            id: "",
+            filename: originalFilename,
+            status: "error_processing",
+            error: fileError instanceof Error ? fileError.message : String(fileError)
+          };
+        }
+      });
+      const results = await Promise.all(processingPromises);
+      sendSuccess(res, results);
+    } else if (isJsonRequest) {
+      const fileUrls = Array.isArray(req.body?.fileUrls) ? req.body?.fileUrls : req.body?.fileUrl ? [req.body?.fileUrl] : [];
+      if (fileUrls.length === 0) {
+        return sendError(res, 400, "MISSING_URL", "File URL is required");
+      }
+      const agentId = req.body?.agentId || req.query?.agentId;
+      if (!agentId) {
+        import_core8.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) => {
+        try {
+          const normalizedUrl = normalizeS3Url(fileUrl);
+          const urlObject = new URL(fileUrl);
+          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}`);
+          const { content, contentType: fetchedContentType } = await fetchUrlContent(fileUrl);
+          let contentType = fetchedContentType;
+          if (contentType === "application/octet-stream") {
+            const fileExtension = originalFilename.split(".").pop()?.toLowerCase();
+            if (fileExtension) {
+              if (["pdf"].includes(fileExtension)) {
+                contentType = "application/pdf";
+              } else if (["txt", "text"].includes(fileExtension)) {
+                contentType = "text/plain";
+              } else if (["md", "markdown"].includes(fileExtension)) {
+                contentType = "text/markdown";
+              } else if (["doc", "docx"].includes(fileExtension)) {
+                contentType = "application/msword";
+              } else if (["html", "htm"].includes(fileExtension)) {
+                contentType = "text/html";
+              } else if (["json"].includes(fileExtension)) {
+                contentType = "application/json";
+              } else if (["xml"].includes(fileExtension)) {
+                contentType = "application/xml";
+              }
+            }
+          }
+          const addKnowledgeOpts = {
+            agentId,
+            clientDocumentId: "",
+            contentType,
+            originalFilename,
+            content,
+            worldId: agentId,
+            roomId: agentId,
+            entityId: agentId,
+            metadata: {
+              url: normalizedUrl
+            }
+          };
+          const result = await service.addKnowledge(addKnowledgeOpts);
+          return {
+            id: result.clientDocumentId,
+            fileUrl,
+            filename: originalFilename,
+            message: "Knowledge created successfully",
+            createdAt: Date.now(),
+            fragmentCount: result.fragmentCount,
+            status: "success"
+          };
+        } catch (urlError) {
+          import_core8.logger.error(`Error processing URL ${fileUrl}: ${urlError instanceof Error ? urlError.message : String(urlError)}`);
+          return {
+            fileUrl,
+            status: "error_processing",
+            error: urlError instanceof Error ? urlError.message : String(urlError)
+          };
+        }
+      });
+      const results = await Promise.all(processingPromises);
+      sendSuccess(res, results);
+    }
+  } catch (error) {
+    import_core8.logger.error({ error }, "Error processing knowledge");
+    if (hasUploadedFiles) {
+      cleanupFiles(req.files);
+    }
+    sendError(res, 500, "PROCESSING_ERROR", "Failed to process knowledge", error instanceof Error ? error.message : String(error));
+  }
+}
+async function getKnowledgeDocumentsHandler(req, res, runtime) {
+  const service = runtime.getService(KnowledgeService.serviceType);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found for getKnowledgeDocumentsHandler");
+  }
+  try {
+    const limit = req.query?.limit ? Number.parseInt(req.query.limit, 10) : 1e4;
+    const before = req.query?.before ? Number.parseInt(req.query.before, 10) : Date.now();
+    const includeEmbedding = req.query?.includeEmbedding === "true";
+    const fileUrls = req.query?.fileUrls ? typeof req.query?.fileUrls === "string" && req.query.fileUrls.includes(",") ? req.query.fileUrls.split(",") : [req.query?.fileUrls] : null;
+    const memories = await service.getMemories({
+      tableName: "documents",
+      count: limit,
+      end: before
+    });
+    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));
+      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) => ({
+      ...memory,
+      embedding: undefined
+    }));
+    sendSuccess(res, {
+      memories: cleanMemories,
+      urlFiltered: !!fileUrls,
+      totalFound: cleanMemories.length,
+      totalRequested: fileUrls ? fileUrls.length : 0
+    });
+  } catch (error) {
+    import_core8.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);
+  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}`);
+    return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
+  }
+  try {
+    const typedKnowledgeId = knowledgeId;
+    import_core8.logger.debug(`Deleting document: ${typedKnowledgeId}`);
+    await service.deleteMemory(typedKnowledgeId);
+    sendSuccess(res, null, 204);
+  } catch (error) {
+    import_core8.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);
+  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}`);
+    return sendError(res, 400, "INVALID_ID", "Invalid Knowledge ID format");
+  }
+  try {
+    import_core8.logger.debug(`Retrieving document: ${knowledgeId}`);
+    const memories = await service.getMemories({
+      tableName: "documents",
+      count: 1e4
+    });
+    const typedKnowledgeId = knowledgeId;
+    const document = memories.find((memory) => memory.id === typedKnowledgeId);
+    if (!document) {
+      return sendError(res, 404, "NOT_FOUND", `Knowledge with ID ${typedKnowledgeId} not found`);
+    }
+    const cleanDocument = {
+      ...document,
+      embedding: undefined
+    };
+    sendSuccess(res, { document: cleanDocument });
+  } catch (error) {
+    import_core8.logger.error({ error }, `Error retrieving document ${knowledgeId}`);
+    sendError(res, 500, "RETRIEVAL_ERROR", "Failed to retrieve document", error instanceof Error ? error.message : String(error));
+  }
+}
+async function knowledgePanelHandler(req, res, runtime) {
+  const agentId = runtime.agentId;
+  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/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");
+      let injectedHtml = html.replace("<head>", `<head>
+          <script>
+            window.ELIZA_CONFIG = {
+              agentId: '${agentId}',
+              apiBase: '${pluginBasePath}'
+            };
+          </script>`);
+      injectedHtml = injectedHtml.replace(/src="\.\/assets\//g, `src="${pluginBasePath}/assets/`);
+      injectedHtml = injectedHtml.replace(/href="\.\/assets\//g, `href="${pluginBasePath}/assets/`);
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(injectedHtml);
+    } else {
+      let cssFile = "index.css";
+      let jsFile = "index.js";
+      const manifestPath = import_node_path.default.join(currentDir, "../dist/manifest.json");
+      if (import_node_fs.default.existsSync(manifestPath)) {
+        try {
+          const manifestContent = await import_node_fs.default.promises.readFile(manifestPath, "utf8");
+          const manifest = JSON.parse(manifestContent);
+          for (const [key, value] of Object.entries(manifest)) {
+            if (typeof value === "object" && value !== null) {
+              const entry = value;
+              if (key.endsWith(".css") || entry.file?.endsWith(".css")) {
+                cssFile = entry.file || key;
+              }
+              if (key.endsWith(".js") || entry.file?.endsWith(".js")) {
+                jsFile = entry.file || key;
+              }
+            }
+          }
+        } catch {}
+      }
+      const html = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Knowledge</title>
+    <script>
+      window.ELIZA_CONFIG = {
+        agentId: '${agentId}',
+        apiBase: '${pluginBasePath}'
+      };
+    </script>
+    <link rel="stylesheet" href="${pluginBasePath}/assets/${cssFile}">
+    <style>
+        body { font-family: system-ui, -apple-system, sans-serif; margin: 0; padding: 20px; }
+        .container { max-width: 1200px; margin: 0 auto; }
+        .loading { text-align: center; padding: 40px; color: #666; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div id="root">
+            <div class="loading">Loading Knowledge Library...</div>
+        </div>
+    </div>
+    <script type="module" src="${pluginBasePath}/assets/${jsFile}"></script>
+</body>
+</html>`;
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(html);
+    }
+  } catch (error) {
+    import_core8.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/milady/plugins/plugin-knowledge/typescript/routes.ts").pathname);
+    const assetsMarker = "/assets/";
+    const assetsStartIndex = fullPath.lastIndexOf(assetsMarker);
+    let assetName = null;
+    if (assetsStartIndex !== -1) {
+      assetName = fullPath.substring(assetsStartIndex + assetsMarker.length);
+      const queryIndex = assetName.indexOf("?");
+      if (queryIndex !== -1) {
+        assetName = assetName.substring(0, queryIndex);
+      }
+    }
+    if (!assetName || assetName.includes("..")) {
+      return sendError(res, 400, "BAD_REQUEST", `Invalid asset name: '${assetName}' from path ${fullPath}`);
+    }
+    const assetPath = import_node_path.default.join(currentDir, "../dist/assets", assetName);
+    if (import_node_fs.default.existsSync(assetPath)) {
+      const fileStream = import_node_fs.default.createReadStream(assetPath);
+      let contentType = "application/octet-stream";
+      if (assetPath.endsWith(".js")) {
+        contentType = "application/javascript";
+      } else if (assetPath.endsWith(".css")) {
+        contentType = "text/css";
+      }
+      res.writeHead(200, { "Content-Type": contentType });
+      fileStream.pipe(asWritableStream(res));
+    } else {
+      sendError(res, 404, "NOT_FOUND", `Asset not found: ${req.url}`);
+    }
+  } catch (error) {
+    import_core8.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);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
+  }
+  try {
+    const documentId = req.query?.documentId;
+    const documentsOnly = req.query?.documentsOnly === "true";
+    const documents = await service.getMemories({
+      tableName: "documents",
+      count: 1e4,
+      end: Date.now()
+    });
+    if (documentsOnly) {
+      sendSuccess(res, {
+        chunks: documents,
+        stats: {
+          documents: documents.length,
+          fragments: 0,
+          mode: "documents-only"
+        }
+      });
+      return;
+    }
+    if (documentId) {
+      const allFragments = await service.getMemories({
+        tableName: "knowledge",
+        count: 50000
+      });
+      const documentFragments = allFragments.filter((fragment) => {
+        const metadata = fragment.metadata;
+        return typeof metadata?.documentId === "string" && metadata.documentId === documentId;
+      });
+      const specificDocument = documents.find((d) => d.id === documentId);
+      const results = specificDocument ? [specificDocument, ...documentFragments] : documentFragments;
+      sendSuccess(res, {
+        chunks: results,
+        stats: {
+          documents: specificDocument ? 1 : 0,
+          fragments: documentFragments.length,
+          mode: "single-document",
+          documentId
+        }
+      });
+      return;
+    }
+    sendSuccess(res, {
+      chunks: documents,
+      stats: {
+        documents: documents.length,
+        fragments: 0,
+        mode: "documents-only"
+      }
+    });
+  } catch (error) {
+    import_core8.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);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
+  }
+  try {
+    const searchText = req.query?.q;
+    const parsedThreshold = req.query?.threshold ? Number.parseFloat(req.query.threshold) : NaN;
+    let matchThreshold = Number.isNaN(parsedThreshold) ? 0.5 : parsedThreshold;
+    matchThreshold = Math.max(0, Math.min(1, matchThreshold));
+    const parsedLimit = req.query?.limit ? Number.parseInt(req.query.limit, 10) : NaN;
+    let limit = Number.isNaN(parsedLimit) ? 20 : parsedLimit;
+    limit = Math.max(1, Math.min(100, limit));
+    const agentId = req.query?.agentId || runtime.agentId;
+    if (!searchText || searchText.trim().length === 0) {
+      return sendError(res, 400, "INVALID_QUERY", "Search query cannot be empty");
+    }
+    const embedding = await runtime.useModel(import_core8.ModelType.TEXT_EMBEDDING, {
+      text: searchText
+    });
+    const results = await runtime.searchMemories({
+      tableName: "knowledge",
+      embedding,
+      query: searchText,
+      count: limit,
+      match_threshold: matchThreshold,
+      roomId: agentId
+    });
+    const enhancedResults = await Promise.all(results.map(async (fragment) => {
+      let documentTitle = "";
+      let documentFilename = "";
+      if (fragment.metadata && typeof fragment.metadata === "object" && "documentId" in fragment.metadata) {
+        const documentId = fragment.metadata.documentId;
+        try {
+          const document = await runtime.getMemoryById(documentId);
+          if (document?.metadata) {
+            const docMetadata = document.metadata;
+            documentTitle = (typeof docMetadata.title === "string" ? docMetadata.title : undefined) || (typeof docMetadata.filename === "string" ? docMetadata.filename : undefined) || "";
+            documentFilename = (typeof docMetadata.filename === "string" ? docMetadata.filename : undefined) || "";
+          }
+        } catch {}
+      }
+      return {
+        id: fragment.id,
+        content: fragment.content,
+        similarity: fragment.similarity || 0,
+        metadata: {
+          ...fragment.metadata || {},
+          documentTitle,
+          documentFilename
+        }
+      };
+    }));
+    sendSuccess(res, {
+      query: searchText,
+      threshold: matchThreshold,
+      results: enhancedResults,
+      count: enhancedResults.length
+    });
+  } catch (error) {
+    import_core8.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);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
+  }
+  try {
+    const parsedPage = req.query?.page ? Number.parseInt(req.query.page, 10) : 1;
+    const parsedLimit = req.query?.limit ? Number.parseInt(req.query.limit, 10) : 20;
+    const type = req.query?.type;
+    const agentId = req.query?.agentId || runtime.agentId;
+    const page = Number.isNaN(parsedPage) || parsedPage < 1 ? 1 : parsedPage;
+    const limit = Number.isNaN(parsedLimit) || parsedLimit < 1 ? 20 : Math.min(parsedLimit, 50);
+    const offset = (page - 1) * limit;
+    const totalDocuments = await service.countMemories({
+      tableName: "documents",
+      roomId: agentId,
+      unique: false
+    });
+    const totalPages = Math.ceil(totalDocuments / limit);
+    const hasMore = page < totalPages;
+    const paginatedDocuments = await service.getMemories({
+      tableName: "documents",
+      roomId: agentId,
+      count: limit,
+      offset
+    });
+    const nodes = [];
+    const links = [];
+    paginatedDocuments.forEach((doc) => {
+      if (!doc.id) {
+        import_core8.logger.warn("Skipping document without ID");
+        return;
+      }
+      nodes.push({ id: doc.id, type: "document" });
+    });
+    if (type !== "document") {
+      const allFragments = await service.getMemories({
+        tableName: "knowledge",
+        roomId: agentId,
+        count: 50000
+      });
+      paginatedDocuments.forEach((doc) => {
+        if (!doc.id) {
+          return;
+        }
+        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;
+          return metadata?.documentId === doc.id && isFragment;
+        });
+        docFragments.forEach((frag) => {
+          const docId = doc.id;
+          if (!frag.id || !docId) {
+            return;
+          }
+          nodes.push({ id: frag.id, type: "fragment" });
+          links.push({ source: docId, target: frag.id });
+        });
+      });
+    }
+    sendSuccess(res, {
+      nodes,
+      links,
+      pagination: {
+        currentPage: page,
+        totalPages,
+        hasMore,
+        totalDocuments
+      }
+    });
+  } catch (error) {
+    import_core8.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);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
+  }
+  const nodeId = req.params?.nodeId;
+  const agentId = req.query?.agentId || runtime.agentId;
+  if (!nodeId || nodeId.length < 36) {
+    return sendError(res, 400, "INVALID_ID", "Invalid node ID format");
+  }
+  try {
+    const allDocuments = await service.getMemories({
+      tableName: "documents",
+      count: 1e4
+    });
+    let document = allDocuments.find((doc) => doc.id === nodeId && doc.roomId === agentId);
+    if (!document) {
+      document = allDocuments.find((doc) => doc.id === nodeId);
+    }
+    if (document) {
+      sendSuccess(res, {
+        id: document.id,
+        type: "document",
+        content: document.content,
+        metadata: document.metadata,
+        createdAt: document.createdAt,
+        entityId: document.entityId,
+        roomId: document.roomId,
+        agentId: document.agentId,
+        worldId: document.worldId
+      });
+      return;
+    }
+    const allFragments = await service.getMemories({
+      tableName: "knowledge",
+      count: 50000
+    });
+    let fragment = allFragments.find((frag) => frag.id === nodeId && frag.roomId === agentId);
+    if (!fragment) {
+      fragment = allFragments.find((frag) => frag.id === nodeId);
+    }
+    if (fragment) {
+      sendSuccess(res, {
+        id: fragment.id,
+        type: "fragment",
+        content: fragment.content,
+        metadata: fragment.metadata,
+        createdAt: fragment.createdAt,
+        entityId: fragment.entityId,
+        roomId: fragment.roomId,
+        agentId: fragment.agentId,
+        worldId: fragment.worldId
+      });
+      return;
+    }
+    import_core8.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}`);
+    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);
+  if (!service) {
+    return sendError(res, 500, "SERVICE_NOT_FOUND", "KnowledgeService not found");
+  }
+  const documentId = req.params?.documentId;
+  const agentId = req.query?.agentId || runtime.agentId;
+  if (!documentId || documentId.length < 36) {
+    return sendError(res, 400, "INVALID_ID", "Invalid document ID format");
+  }
+  try {
+    const allFragments = await service.getMemories({
+      tableName: "knowledge",
+      roomId: agentId,
+      count: 50000
+    });
+    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;
+      return metadata?.documentId === documentId && isFragment;
+    });
+    const nodes = documentFragments.filter((frag) => frag.id !== undefined).map((frag) => ({
+      id: frag.id,
+      type: "fragment"
+    }));
+    const links = documentFragments.filter((frag) => frag.id !== undefined).map((frag) => ({
+      source: documentId,
+      target: frag.id
+    }));
+    sendSuccess(res, {
+      documentId,
+      nodes,
+      links,
+      fragmentCount: nodes.length
+    });
+  } catch (error) {
+    import_core8.logger.error({ error }, `Error expanding document ${documentId}`);
+    sendError(res, 500, "GRAPH_ERROR", "Failed to expand document", error instanceof Error ? error.message : String(error));
+  }
+}
+async function uploadKnowledgeWithMulter(req, res, runtime) {
+  const upload = createUploadMiddleware(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");
+      return sendError(res, 400, "UPLOAD_ERROR", err.message);
+    }
+    uploadKnowledgeHandler(req, res, runtime);
+  });
+}
+function asRouteHandler(handler) {
+  return handler;
+}
+var knowledgeRoutes = [
+  {
+    type: "GET",
+    name: "Knowledge",
+    path: "/display",
+    handler: asRouteHandler(knowledgePanelHandler),
+    public: true
+  },
+  {
+    type: "GET",
+    path: "/assets/*",
+    handler: asRouteHandler(frontendAssetHandler)
+  },
+  {
+    type: "POST",
+    path: "/documents",
+    handler: asRouteHandler(uploadKnowledgeWithMulter)
+  },
+  {
+    type: "GET",
+    path: "/documents",
+    handler: asRouteHandler(getKnowledgeDocumentsHandler)
+  },
+  {
+    type: "GET",
+    path: "/documents/:knowledgeId",
+    handler: asRouteHandler(getKnowledgeByIdHandler)
+  },
+  {
+    type: "DELETE",
+    path: "/documents/:knowledgeId",
+    handler: asRouteHandler(deleteKnowledgeDocumentHandler)
+  },
+  {
+    type: "GET",
+    path: "/knowledges",
+    handler: asRouteHandler(getKnowledgeChunksHandler)
+  },
+  {
+    type: "GET",
+    path: "/search",
+    handler: asRouteHandler(searchKnowledgeHandler)
+  },
+  {
+    type: "GET",
+    path: "/graph/nodes",
+    handler: asRouteHandler(getGraphNodesHandler)
+  },
+  {
+    type: "GET",
+    path: "/graph/node/:nodeId",
+    handler: asRouteHandler(getGraphNodeDetailsHandler)
+  },
+  {
+    type: "GET",
+    path: "/graph/expand/:documentId",
+    handler: asRouteHandler(expandDocumentGraphHandler)
+  }
+];
+
+// 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]
+  };
+  if (enableUI || enableRoutes) {
+    plugin.routes = knowledgeRoutes;
+  }
+  if (enableActions) {
+    plugin.actions = knowledgeActions;
+  }
+  if (enableTests) {}
+  return plugin;
+}
+var knowledgePluginCore = createKnowledgePlugin({
+  enableUI: false,
+  enableRoutes: false,
+  enableActions: false,
+  enableTests: false
+});
+var knowledgePluginHeadless = createKnowledgePlugin({
+  enableUI: false,
+  enableRoutes: false,
+  enableActions: true,
+  enableTests: false
+});
+var knowledgePlugin = createKnowledgePlugin({
+  enableUI: true,
+  enableRoutes: true,
+  enableActions: true,
+  enableTests: true
+});
+
+//# debugId=83F51FED4EE57D6B64756E2164756E21
+//# sourceMappingURL=index.node.cjs.map