@elizaos/plugin-local-embedding 2.0.0-alpha.10

package/dist/index.js

@@ -0,0 +1,1886 @@
+// src/index.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2, { basename } from "path";
+import { logger as logger5, ModelType } from "@elizaos/core";
+import {
+  getLlama,
+  LlamaLogLevel
+} from "node-llama-cpp";
+
+// src/environment.ts
+import { logger } from "@elizaos/core";
+import { z } from "zod";
+var DEFAULT_EMBEDDING_MODEL = "bge-small-en-v1.5.Q4_K_M.gguf";
+var configSchema = z.object({
+  LOCAL_EMBEDDING_MODEL: z.string().optional().default(DEFAULT_EMBEDDING_MODEL),
+  LOCAL_EMBEDDING_MODEL_REPO: z.string().optional(),
+  MODELS_DIR: z.string().optional(),
+  // Path for the models directory
+  CACHE_DIR: z.string().optional(),
+  // Path for the cache directory
+  LOCAL_EMBEDDING_DIMENSIONS: z.string().optional().transform((val) => {
+    if (!val || !val.trim()) return void 0;
+    const parsed = Number.parseInt(val, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+  }),
+  LOCAL_EMBEDDING_CONTEXT_SIZE: z.string().optional().transform((val) => {
+    if (!val || !val.trim()) return void 0;
+    const parsed = Number.parseInt(val, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+  }),
+  LOCAL_EMBEDDING_GPU_LAYERS: z.string().optional().default("0").transform((val) => {
+    if (val === "auto") return -1;
+    const num = parseInt(val, 10);
+    return Number.isNaN(num) ? 0 : num;
+  }),
+  LOCAL_EMBEDDING_USE_MMAP: z.string().optional().default("true").transform((val) => val === "true")
+});
+function validateConfig() {
+  try {
+    const configToParse = {
+      LOCAL_EMBEDDING_MODEL: process.env.LOCAL_EMBEDDING_MODEL,
+      LOCAL_EMBEDDING_MODEL_REPO: process.env.LOCAL_EMBEDDING_MODEL_REPO,
+      MODELS_DIR: process.env.MODELS_DIR,
+      // Read models directory path from env
+      CACHE_DIR: process.env.CACHE_DIR,
+      // Read cache directory path from env
+      LOCAL_EMBEDDING_DIMENSIONS: process.env.LOCAL_EMBEDDING_DIMENSIONS,
+      // Read embedding dimensions
+      LOCAL_EMBEDDING_CONTEXT_SIZE: process.env.LOCAL_EMBEDDING_CONTEXT_SIZE,
+      LOCAL_EMBEDDING_GPU_LAYERS: process.env.LOCAL_EMBEDDING_GPU_LAYERS,
+      LOCAL_EMBEDDING_USE_MMAP: process.env.LOCAL_EMBEDDING_USE_MMAP
+    };
+    logger.debug(
+      {
+        LOCAL_EMBEDDING_MODEL: configToParse.LOCAL_EMBEDDING_MODEL,
+        LOCAL_EMBEDDING_MODEL_REPO: configToParse.LOCAL_EMBEDDING_MODEL_REPO,
+        MODELS_DIR: configToParse.MODELS_DIR,
+        CACHE_DIR: configToParse.CACHE_DIR,
+        LOCAL_EMBEDDING_DIMENSIONS: configToParse.LOCAL_EMBEDDING_DIMENSIONS,
+        LOCAL_EMBEDDING_CONTEXT_SIZE: configToParse.LOCAL_EMBEDDING_CONTEXT_SIZE,
+        LOCAL_EMBEDDING_GPU_LAYERS: configToParse.LOCAL_EMBEDDING_GPU_LAYERS,
+        LOCAL_EMBEDDING_USE_MMAP: configToParse.LOCAL_EMBEDDING_USE_MMAP
+      },
+      "Validating configuration for local AI plugin from env:"
+    );
+    const validatedConfig = configSchema.parse(configToParse);
+    logger.info(validatedConfig, "Using local AI configuration:");
+    return validatedConfig;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n");
+      logger.error(errorMessages, "Zod validation failed:");
+      throw new Error(`Configuration validation failed:
+${errorMessages}`);
+    }
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      },
+      "Configuration validation failed:"
+    );
+    throw error;
+  }
+}
+
+// src/types.ts
+var MODEL_SPECS = {
+  small: {
+    name: "DeepHermes-3-Llama-3-3B-Preview-q4.gguf",
+    repo: "NousResearch/DeepHermes-3-Llama-3-3B-Preview-GGUF",
+    size: "3B",
+    quantization: "Q4_0",
+    contextSize: 8192,
+    tokenizer: {
+      name: "NousResearch/DeepHermes-3-Llama-3-3B-Preview",
+      type: "llama"
+    }
+  },
+  medium: {
+    name: "DeepHermes-3-Llama-3-8B-q4.gguf",
+    repo: "NousResearch/DeepHermes-3-Llama-3-8B-Preview-GGUF",
+    size: "8B",
+    quantization: "Q4_0",
+    contextSize: 8192,
+    tokenizer: {
+      name: "NousResearch/DeepHermes-3-Llama-3-8B-Preview",
+      type: "llama"
+    }
+  },
+  embedding: {
+    name: "bge-small-en-v1.5.Q4_K_M.gguf",
+    repo: "ChristianAzinn/bge-small-en-v1.5-gguf",
+    size: "133 MB",
+    quantization: "Q4_K_M",
+    contextSize: 512,
+    dimensions: 384,
+    tokenizer: {
+      name: "ChristianAzinn/bge-small-en-v1.5-gguf",
+      type: "llama"
+    }
+  },
+  vision: {
+    name: "Florence-2-base-ft",
+    repo: "onnx-community/Florence-2-base-ft",
+    size: "0.23B",
+    modelId: "onnx-community/Florence-2-base-ft",
+    contextSize: 1024,
+    maxTokens: 256,
+    tasks: [
+      "CAPTION",
+      "DETAILED_CAPTION",
+      "MORE_DETAILED_CAPTION",
+      "CAPTION_TO_PHRASE_GROUNDING",
+      "OD",
+      "DENSE_REGION_CAPTION",
+      "REGION_PROPOSAL",
+      "OCR",
+      "OCR_WITH_REGION"
+    ]
+  },
+  visionvl: {
+    name: "Qwen2.5-VL-3B-Instruct",
+    repo: "Qwen/Qwen2.5-VL-3B-Instruct",
+    size: "3B",
+    modelId: "Qwen/Qwen2.5-VL-3B-Instruct",
+    contextSize: 32768,
+    maxTokens: 1024,
+    tasks: [
+      "CAPTION",
+      "DETAILED_CAPTION",
+      "IMAGE_UNDERSTANDING",
+      "VISUAL_QUESTION_ANSWERING",
+      "OCR",
+      "VISUAL_LOCALIZATION",
+      "REGION_ANALYSIS"
+    ]
+  },
+  tts: {
+    default: {
+      modelId: "Xenova/speecht5_tts",
+      defaultSampleRate: 16e3,
+      // SpeechT5 default
+      // Use the standard embedding URL
+      defaultSpeakerEmbeddingUrl: "https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/speaker_embeddings.bin"
+    }
+  }
+};
+
+// src/utils/downloadManager.ts
+import fs from "fs";
+import https from "https";
+import path from "path";
+import { logger as logger2 } from "@elizaos/core";
+function parseContentLength(contentLength) {
+  if (!contentLength || Array.isArray(contentLength)) return null;
+  const parsed = Number.parseInt(contentLength, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+var DownloadManager = class _DownloadManager {
+  static instance = null;
+  cacheDir;
+  modelsDir;
+  // Track active downloads to prevent duplicates
+  activeDownloads = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new instance of CacheManager.
+   *
+   * @param {string} cacheDir - The directory path for caching data.
+   * @param {string} modelsDir - The directory path for model files.
+   */
+  constructor(cacheDir, modelsDir) {
+    this.cacheDir = cacheDir;
+    this.modelsDir = modelsDir;
+    this.ensureCacheDirectory();
+    this.ensureModelsDirectory();
+  }
+  /**
+   * Returns the singleton instance of the DownloadManager class.
+   * If an instance does not already exist, it creates a new one using the provided cache directory and models directory.
+   *
+   * @param {string} cacheDir - The directory where downloaded files are stored.
+   * @param {string} modelsDir - The directory where model files are stored.
+   * @returns {DownloadManager} The singleton instance of the DownloadManager class.
+   */
+  static getInstance(cacheDir, modelsDir) {
+    if (!_DownloadManager.instance) {
+      _DownloadManager.instance = new _DownloadManager(cacheDir, modelsDir);
+    }
+    return _DownloadManager.instance;
+  }
+  /**
+   * Ensure that the cache directory exists.
+   */
+  ensureCacheDirectory() {
+    if (!fs.existsSync(this.cacheDir)) {
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+      logger2.debug("Created cache directory");
+    }
+  }
+  /**
+   * Ensure that the models directory exists. If it does not exist, create it.
+   */
+  ensureModelsDirectory() {
+    logger2.debug("Ensuring models directory exists:", this.modelsDir);
+    if (!fs.existsSync(this.modelsDir)) {
+      fs.mkdirSync(this.modelsDir, { recursive: true });
+      logger2.debug("Created models directory");
+    }
+  }
+  /**
+   * Downloads a file from a given URL to a specified destination path asynchronously.
+   *
+   * @param {string} url - The URL from which to download the file.
+   * @param {string} destPath - The destination path where the downloaded file will be saved.
+   * @returns {Promise<void>} A Promise that resolves when the file download is completed successfully or rejects if an error occurs.
+   */
+  async downloadFileInternal(url, destPath) {
+    return new Promise((resolve, reject) => {
+      logger2.info(`Starting download to: ${destPath}`);
+      const tempPath = `${destPath}.tmp`;
+      if (fs.existsSync(tempPath)) {
+        try {
+          logger2.warn(`Removing existing temporary file: ${tempPath}`);
+          fs.unlinkSync(tempPath);
+        } catch (err) {
+          logger2.error(
+            `Failed to remove existing temporary file: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      const request = https.get(
+        url,
+        {
+          headers: {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+          },
+          timeout: 3e5
+          // Increase timeout to 5 minutes
+        },
+        (response) => {
+          if (response.statusCode === 301 || response.statusCode === 302) {
+            const redirectUrl = response.headers.location;
+            if (!redirectUrl) {
+              reject(new Error("Redirect location not found"));
+              return;
+            }
+            this.activeDownloads.delete(destPath);
+            this.downloadFile(redirectUrl, destPath).then(resolve).catch(reject);
+            return;
+          }
+          if (response.statusCode !== 200) {
+            reject(new Error(`Failed to download: ${response.statusCode}`));
+            return;
+          }
+          const expectedBytes = parseContentLength(response.headers["content-length"]);
+          const totalSize = expectedBytes ?? 0;
+          let downloadedSize = 0;
+          let lastLoggedPercent = 0;
+          const barLength = 30;
+          const fileName = path.basename(destPath);
+          logger2.info(`Downloading ${fileName}: ${"\u25B1".repeat(barLength)} 0%`);
+          const file = fs.createWriteStream(tempPath);
+          response.on("data", (chunk) => {
+            downloadedSize += chunk.length;
+            if (!totalSize) return;
+            const percent = Math.round(downloadedSize / totalSize * 100);
+            if (percent >= lastLoggedPercent + 5) {
+              const filledLength = Math.floor(downloadedSize / totalSize * barLength);
+              const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
+              logger2.info(`Downloading ${fileName}: ${progressBar} ${percent}%`);
+              lastLoggedPercent = percent;
+            }
+          });
+          response.pipe(file);
+          file.on("finish", () => {
+            file.close(() => {
+              try {
+                const completedBar = "\u25B0".repeat(barLength);
+                logger2.info(`Downloading ${fileName}: ${completedBar} 100%`);
+                const destDir = path.dirname(destPath);
+                if (!fs.existsSync(destDir)) {
+                  fs.mkdirSync(destDir, { recursive: true });
+                }
+                if (!fs.existsSync(tempPath)) {
+                  reject(new Error(`Temporary file ${tempPath} does not exist`));
+                  return;
+                }
+                if (expectedBytes !== null && downloadedSize !== expectedBytes) {
+                  try {
+                    fs.unlinkSync(tempPath);
+                  } catch {
+                  }
+                  reject(
+                    new Error(
+                      `Downloaded file size mismatch for ${destPath}: expected ${expectedBytes} bytes, got ${downloadedSize}`
+                    )
+                  );
+                  return;
+                }
+                if (fs.existsSync(destPath)) {
+                  try {
+                    const backupPath = `${destPath}.bak`;
+                    fs.renameSync(destPath, backupPath);
+                    logger2.info(`Created backup of existing file: ${backupPath}`);
+                    fs.renameSync(tempPath, destPath);
+                    if (fs.existsSync(backupPath)) {
+                      fs.unlinkSync(backupPath);
+                      logger2.info(`Removed backup file after successful update: ${backupPath}`);
+                    }
+                  } catch (moveErr) {
+                    logger2.error(
+                      `Error replacing file: ${moveErr instanceof Error ? moveErr.message : String(moveErr)}`
+                    );
+                    const backupPath = `${destPath}.bak`;
+                    if (fs.existsSync(backupPath)) {
+                      try {
+                        fs.renameSync(backupPath, destPath);
+                        logger2.info(`Restored from backup after failed update: ${backupPath}`);
+                      } catch (restoreErr) {
+                        logger2.error(
+                          `Failed to restore from backup: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`
+                        );
+                      }
+                    }
+                    if (fs.existsSync(tempPath)) {
+                      try {
+                        fs.unlinkSync(tempPath);
+                      } catch (unlinkErr) {
+                        logger2.error(
+                          `Failed to clean up temp file: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
+                        );
+                      }
+                    }
+                    reject(moveErr);
+                    return;
+                  }
+                } else {
+                  fs.renameSync(tempPath, destPath);
+                }
+                logger2.success(`Download of ${fileName} completed successfully`);
+                this.activeDownloads.delete(destPath);
+                resolve();
+              } catch (err) {
+                logger2.error(
+                  `Error finalizing download: ${err instanceof Error ? err.message : String(err)}`
+                );
+                if (fs.existsSync(tempPath)) {
+                  try {
+                    fs.unlinkSync(tempPath);
+                  } catch (unlinkErr) {
+                    logger2.error(
+                      `Failed to clean up temp file: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
+                    );
+                  }
+                }
+                this.activeDownloads.delete(destPath);
+                reject(err);
+              }
+            });
+          });
+          file.on("error", (err) => {
+            logger2.error(`File write error: ${err instanceof Error ? err.message : String(err)}`);
+            file.close(() => {
+              if (fs.existsSync(tempPath)) {
+                try {
+                  fs.unlinkSync(tempPath);
+                } catch (unlinkErr) {
+                  logger2.error(
+                    `Failed to clean up temp file after error: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
+                  );
+                }
+              }
+              this.activeDownloads.delete(destPath);
+              reject(err);
+            });
+          });
+        }
+      );
+      request.on("error", (err) => {
+        logger2.error(`Request error: ${err instanceof Error ? err.message : String(err)}`);
+        if (fs.existsSync(tempPath)) {
+          try {
+            fs.unlinkSync(tempPath);
+          } catch (unlinkErr) {
+            logger2.error(
+              `Failed to clean up temp file after request error: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
+            );
+          }
+        }
+        this.activeDownloads.delete(destPath);
+        reject(err);
+      });
+      request.on("timeout", () => {
+        logger2.error("Download timeout occurred");
+        request.destroy();
+        if (fs.existsSync(tempPath)) {
+          try {
+            fs.unlinkSync(tempPath);
+          } catch (unlinkErr) {
+            logger2.error(
+              `Failed to clean up temp file after timeout: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
+            );
+          }
+        }
+        this.activeDownloads.delete(destPath);
+        reject(new Error("Download timeout"));
+      });
+    });
+  }
+  /**
+   * Asynchronously downloads a file from the specified URL to the destination path.
+   *
+   * @param {string} url - The URL of the file to download.
+   * @param {string} destPath - The destination path to save the downloaded file.
+   * @returns {Promise<void>} A Promise that resolves once the file has been successfully downloaded.
+   */
+  async downloadFile(url, destPath) {
+    if (this.activeDownloads.has(destPath)) {
+      logger2.info(`Download for ${destPath} already in progress, waiting for it to complete...`);
+      const existingDownload = this.activeDownloads.get(destPath);
+      if (existingDownload) {
+        return existingDownload;
+      }
+      logger2.warn(
+        `Download for ${destPath} was marked as in progress but not found in tracking map`
+      );
+    }
+    const downloadPromise = this.downloadFileInternal(url, destPath);
+    this.activeDownloads.set(destPath, downloadPromise);
+    try {
+      return await downloadPromise;
+    } catch (error) {
+      this.activeDownloads.delete(destPath);
+      throw error;
+    }
+  }
+  /**
+   * Downloads a model specified by the modelSpec and saves it to the provided modelPath.
+   * If the model is successfully downloaded, returns true, otherwise returns false.
+   *
+   * @param {ModelSpec} modelSpec - The model specification containing repo and name.
+   * @param {string} modelPath - The path where the model will be saved.
+   * @returns {Promise<boolean>} - Indicates if the model was successfully downloaded or not.
+   */
+  async downloadModel(modelSpec, modelPath, forceDownload = false) {
+    try {
+      logger2.info("Starting local model download...");
+      const modelDir = path.dirname(modelPath);
+      if (!fs.existsSync(modelDir)) {
+        logger2.info("Creating model directory:", modelDir);
+        fs.mkdirSync(modelDir, { recursive: true });
+      }
+      if (!fs.existsSync(modelPath) || forceDownload) {
+        if (forceDownload && fs.existsSync(modelPath)) {
+          logger2.warn("Force re-download requested; removing existing model file:", modelPath);
+          this.activeDownloads.delete(modelPath);
+          try {
+            fs.unlinkSync(modelPath);
+          } catch (err) {
+            logger2.warn(
+              `Failed to remove existing model file before re-download: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        const attempts = [
+          {
+            description: "LFS URL with GGUF suffix",
+            url: `https://huggingface.co/${modelSpec.repo}/resolve/main/${modelSpec.name}?download=true`
+          },
+          {
+            description: "LFS URL without GGUF suffix",
+            url: `https://huggingface.co/${modelSpec.repo.replace("-GGUF", "")}/resolve/main/${modelSpec.name}?download=true`
+          },
+          {
+            description: "Standard URL with GGUF suffix",
+            url: `https://huggingface.co/${modelSpec.repo}/resolve/main/${modelSpec.name}`
+          },
+          {
+            description: "Standard URL without GGUF suffix",
+            url: `https://huggingface.co/${modelSpec.repo.replace("-GGUF", "")}/resolve/main/${modelSpec.name}`
+          }
+        ];
+        let lastError = null;
+        let downloadSuccess = false;
+        for (const attempt of attempts) {
+          try {
+            logger2.info("Attempting model download:", {
+              description: attempt.description,
+              url: attempt.url,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            await this.downloadFile(attempt.url, modelPath);
+            logger2.success(
+              `Model download complete: ${modelSpec.name} using ${attempt.description}`
+            );
+            downloadSuccess = true;
+            break;
+          } catch (error) {
+            lastError = error;
+            logger2.warn("Model download attempt failed:", {
+              description: attempt.description,
+              error: error instanceof Error ? error.message : String(error),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        if (!downloadSuccess) {
+          throw lastError || new Error("All download attempts failed");
+        }
+        return true;
+      }
+      logger2.info("Model already exists at:", modelPath);
+      return false;
+    } catch (error) {
+      logger2.error("Model download failed:", {
+        error: error instanceof Error ? error.message : String(error),
+        modelPath,
+        model: modelSpec.name
+      });
+      throw error;
+    }
+  }
+  /**
+   * Returns the cache directory path.
+   *
+   * @returns {string} The path of the cache directory.
+   */
+  getCacheDir() {
+    return this.cacheDir;
+  }
+  /**
+   * Downloads a file from a given URL to a specified destination path.
+   *
+   * @param {string} url - The URL of the file to download.
+   * @param {string} destPath - The destination path where the file should be saved.
+   * @returns {Promise<void>} A Promise that resolves once the file has been downloaded.
+   */
+  async downloadFromUrl(url, destPath) {
+    return this.downloadFile(url, destPath);
+  }
+  /**
+   * Ensures that the specified directory exists. If it does not exist, it will be created.
+   * @param {string} dirPath - The path of the directory to ensure existence of.
+   * @returns {void}
+   */
+  ensureDirectoryExists(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+      logger2.info(`Created directory: ${dirPath}`);
+    }
+  }
+};
+
+// src/utils/platform.ts
+import { exec } from "child_process";
+import os from "os";
+import { promisify } from "util";
+import { logger as logger3 } from "@elizaos/core";
+var execAsync = promisify(exec);
+var PlatformManager = class _PlatformManager {
+  static instance;
+  capabilities = null;
+  /**
+   * Private constructor method.
+   */
+  constructor() {
+  }
+  /**
+   * Get the singleton instance of the PlatformManager class
+   * @returns {PlatformManager} The instance of PlatformManager
+   */
+  static getInstance() {
+    if (!_PlatformManager.instance) {
+      _PlatformManager.instance = new _PlatformManager();
+    }
+    return _PlatformManager.instance;
+  }
+  /**
+   * Asynchronous method to initialize platform detection.
+   *
+   * @returns {Promise<void>} Promise that resolves once platform detection is completed.
+   */
+  async initialize() {
+    try {
+      logger3.info("Initializing platform detection...");
+      this.capabilities = await this.detectSystemCapabilities();
+    } catch (error) {
+      logger3.error("Platform detection failed", { error });
+      throw error;
+    }
+  }
+  /**
+   * Detects the system capabilities including platform, CPU information, GPU information,
+   * supported backends, and recommended model size.
+   *
+   * @returns {Promise<SystemCapabilities>} Details of the system capabilities including platform, CPU info, GPU info,
+   * recommended model size, and supported backends.
+   */
+  async detectSystemCapabilities() {
+    const platform = process.platform;
+    const cpuInfo = this.getCPUInfo();
+    const gpu = await this.detectGPU();
+    const supportedBackends = await this.getSupportedBackends(platform, gpu);
+    const recommendedModelSize = this.getRecommendedModelSize(cpuInfo, gpu);
+    return {
+      platform,
+      cpu: cpuInfo,
+      gpu,
+      recommendedModelSize,
+      supportedBackends
+    };
+  }
+  /**
+   * Returns information about the CPU and memory of the system.
+   * @returns {SystemCPU} The CPU information including model, number of cores, speed, architecture, and memory details.
+   */
+  getCPUInfo() {
+    const cpus = os.cpus();
+    const totalMemory = os.totalmem();
+    const freeMemory = os.freemem();
+    return {
+      model: cpus[0].model,
+      cores: cpus.length,
+      speed: cpus[0].speed,
+      architecture: process.arch,
+      memory: {
+        total: totalMemory,
+        free: freeMemory
+      }
+    };
+  }
+  /**
+   * Asynchronously detects the GPU information based on the current platform.
+   * @returns A promise that resolves with the GPU information if detection is successful, otherwise null.
+   */
+  async detectGPU() {
+    const platform = process.platform;
+    try {
+      switch (platform) {
+        case "darwin":
+          return await this.detectMacGPU();
+        case "win32":
+          return await this.detectWindowsGPU();
+        case "linux":
+          return await this.detectLinuxGPU();
+        default:
+          return null;
+      }
+    } catch (error) {
+      logger3.error("GPU detection failed", { error });
+      return null;
+    }
+  }
+  /**
+   * Asynchronously detects the GPU of a Mac system.
+   * @returns {Promise<SystemGPU>} A promise that resolves to an object representing the detected GPU.
+   */
+  async detectMacGPU() {
+    try {
+      const { stdout } = await execAsync("sysctl -n machdep.cpu.brand_string");
+      const isAppleSilicon = stdout.toLowerCase().includes("apple");
+      if (isAppleSilicon) {
+        return {
+          name: "Apple Silicon",
+          type: "metal",
+          isAppleSilicon: true
+        };
+      }
+      const { stdout: gpuInfo } = await execAsync("system_profiler SPDisplaysDataType");
+      return {
+        name: gpuInfo.split("Chipset Model:")[1]?.split("\n")[0]?.trim() || "Unknown GPU",
+        type: "metal",
+        isAppleSilicon: false
+      };
+    } catch (error) {
+      logger3.error("Mac GPU detection failed", { error });
+      return {
+        name: "Unknown Mac GPU",
+        type: "metal",
+        isAppleSilicon: false
+      };
+    }
+  }
+  /**
+   * Detects the GPU in a Windows system and returns information about it.
+   *
+   * @returns {Promise<SystemGPU | null>} A promise that resolves with the detected GPU information or null if detection fails.
+   */
+  async detectWindowsGPU() {
+    try {
+      const { stdout } = await execAsync("wmic path win32_VideoController get name");
+      const gpuName = stdout.split("\n")[1].trim();
+      if (gpuName.toLowerCase().includes("nvidia")) {
+        const { stdout: nvidiaInfo } = await execAsync(
+          "nvidia-smi --query-gpu=name,memory.total --format=csv,noheader"
+        );
+        const [name, memoryStr] = nvidiaInfo.split(",").map((s) => s.trim());
+        const memory = Number.parseInt(memoryStr, 10);
+        return {
+          name,
+          memory,
+          type: "cuda",
+          version: await this.getNvidiaDriverVersion()
+        };
+      }
+      return {
+        name: gpuName,
+        type: "directml"
+      };
+    } catch (error) {
+      logger3.error("Windows GPU detection failed", { error });
+      return null;
+    }
+  }
+  /**
+   * Asynchronously detects the GPU information for Linux systems.
+   * Tries to detect NVIDIA GPU first using 'nvidia-smi' command and if successful,
+   * returns the GPU name, memory size, type as 'cuda', and NVIDIA driver version.
+   * If NVIDIA detection fails, it falls back to checking for other GPUs using 'lspci | grep -i vga' command.
+   * If no GPU is detected, it returns null.
+   *
+   * @returns {Promise<SystemGPU | null>} The detected GPU information or null if detection fails.
+   */
+  async detectLinuxGPU() {
+    try {
+      const { stdout } = await execAsync(
+        "nvidia-smi --query-gpu=name,memory.total --format=csv,noheader"
+      );
+      if (stdout) {
+        const [name, memoryStr] = stdout.split(",").map((s) => s.trim());
+        const memory = Number.parseInt(memoryStr, 10);
+        return {
+          name,
+          memory,
+          type: "cuda",
+          version: await this.getNvidiaDriverVersion()
+        };
+      }
+    } catch {
+      try {
+        const { stdout } = await execAsync("lspci | grep -i vga");
+        return {
+          name: stdout.split(":").pop()?.trim() || "Unknown GPU",
+          type: "none"
+        };
+      } catch (error) {
+        logger3.error("Linux GPU detection failed", { error });
+        return null;
+      }
+    }
+    return null;
+  }
+  /**
+   * Asynchronously retrieves the driver version of the Nvidia GPU using the 'nvidia-smi' command.
+   *
+   * @returns A promise that resolves with the driver version as a string, or 'unknown' if an error occurs.
+   */
+  async getNvidiaDriverVersion() {
+    try {
+      const { stdout } = await execAsync(
+        "nvidia-smi --query-gpu=driver_version --format=csv,noheader"
+      );
+      return stdout.trim();
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Retrieves the supported backends based on the platform and GPU type.
+   * @param {NodeJS.Platform} platform - The platform on which the code is running.
+   * @param {SystemGPU | null} gpu - The GPU information, if available.
+   * @returns {Promise<Array<"cuda" | "metal" | "directml" | "cpu">>} - An array of supported backends including 'cuda', 'metal', 'directml', and 'cpu'.
+   */
+  async getSupportedBackends(platform, gpu) {
+    const backends = ["cpu"];
+    if (gpu) {
+      switch (platform) {
+        case "darwin":
+          backends.push("metal");
+          break;
+        case "win32":
+          if (gpu.type === "cuda") {
+            backends.push("cuda");
+          }
+          backends.push("directml");
+          break;
+        case "linux":
+          if (gpu.type === "cuda") {
+            backends.push("cuda");
+          }
+          break;
+      }
+    }
+    return backends;
+  }
+  /**
+   * Determines the recommended model size based on the system's CPU and GPU.
+   * @param {SystemCPU} cpu - The system's CPU.
+   * @param {SystemGPU | null} gpu - The system's GPU, if available.
+   * @returns {"small" | "medium" | "large"} - The recommended model size ("small", "medium", or "large").
+   */
+  getRecommendedModelSize(cpu, gpu) {
+    if (gpu?.isAppleSilicon) {
+      return cpu.memory.total > 16 * 1024 * 1024 * 1024 ? "medium" : "small";
+    }
+    if (gpu?.type === "cuda") {
+      const gpuMemGB = (gpu.memory || 0) / 1024;
+      if (gpuMemGB >= 16) return "large";
+      if (gpuMemGB >= 8) return "medium";
+    }
+    if (cpu.memory.total > 32 * 1024 * 1024 * 1024) return "medium";
+    return "small";
+  }
+  /**
+   * Returns the SystemCapabilities of the PlatformManager.
+   *
+   * @returns {SystemCapabilities} The SystemCapabilities of the PlatformManager.
+   * @throws {Error} if PlatformManager is not initialized.
+   */
+  getCapabilities() {
+    if (!this.capabilities) {
+      throw new Error("PlatformManager not initialized");
+    }
+    return this.capabilities;
+  }
+  /**
+   * Checks if the device's GPU is Apple Silicon.
+   * @returns {boolean} True if the GPU is Apple Silicon, false otherwise.
+   */
+  isAppleSilicon() {
+    return !!this.capabilities?.gpu?.isAppleSilicon;
+  }
+  /**
+   * Checks if the current device has GPU support.
+   * @returns {boolean} - Returns true if the device has GPU support, false otherwise.
+   */
+  hasGPUSupport() {
+    return !!this.capabilities?.gpu;
+  }
+  /**
+   * Checks if the system supports CUDA GPU for processing.
+   *
+   * @returns {boolean} True if the system supports CUDA, false otherwise.
+   */
+  supportsCUDA() {
+    return this.capabilities?.gpu?.type === "cuda";
+  }
+  /**
+   * Check if the device supports Metal API for rendering graphics.
+   * @returns {boolean} True if the device supports Metal, false otherwise.
+   */
+  supportsMetal() {
+    return this.capabilities?.gpu?.type === "metal";
+  }
+  /**
+   * Check if the device supports DirectML for GPU acceleration.
+   *
+   * @returns {boolean} True if the device supports DirectML, false otherwise.
+   */
+  supportsDirectML() {
+    return this.capabilities?.gpu?.type === "directml";
+  }
+  /**
+   * Get the recommended backend for computation based on the available capabilities.
+   * @returns {"cuda" | "metal" | "directml" | "cpu"} The recommended backend for computation.
+   * @throws {Error} Throws an error if PlatformManager is not initialized.
+   */
+  getRecommendedBackend() {
+    if (!this.capabilities) {
+      throw new Error("PlatformManager not initialized");
+    }
+    const { gpu, supportedBackends } = this.capabilities;
+    if (gpu?.type === "cuda") return "cuda";
+    if (gpu?.type === "metal") return "metal";
+    if (supportedBackends.includes("directml")) return "directml";
+    return "cpu";
+  }
+};
+var getPlatformManager = () => {
+  return PlatformManager.getInstance();
+};
+
+// src/utils/tokenizerManager.ts
+import { logger as logger4 } from "@elizaos/core";
+import { AutoTokenizer } from "@huggingface/transformers";
+var TokenizerManager = class _TokenizerManager {
+  static instance = null;
+  tokenizers;
+  cacheDir;
+  modelsDir;
+  /**
+   * Constructor for creating a new instance of the class.
+   *
+   * @param {string} cacheDir - The directory for caching data.
+   * @param {string} modelsDir - The directory for storing models.
+   */
+  constructor(cacheDir, modelsDir) {
+    this.tokenizers = /* @__PURE__ */ new Map();
+    this.cacheDir = cacheDir;
+    this.modelsDir = modelsDir;
+  }
+  /**
+   * Get the singleton instance of TokenizerManager class. If the instance does not exist, it will create a new one.
+   *
+   * @param {string} cacheDir - The directory to cache the tokenizer models.
+   * @param {string} modelsDir - The directory where tokenizer models are stored.
+   * @returns {TokenizerManager} The singleton instance of TokenizerManager.
+   */
+  static getInstance(cacheDir, modelsDir) {
+    if (!_TokenizerManager.instance) {
+      _TokenizerManager.instance = new _TokenizerManager(cacheDir, modelsDir);
+    }
+    return _TokenizerManager.instance;
+  }
+  /**
+   * Asynchronously loads a tokenizer based on the provided ModelSpec configuration.
+   *
+   * @param {ModelSpec} modelConfig - The configuration object for the model to load the tokenizer for.
+   * @returns {Promise<PreTrainedTokenizer>} - A promise that resolves to the loaded tokenizer.
+   */
+  async loadTokenizer(modelConfig) {
+    try {
+      const tokenizerKey = `${modelConfig.tokenizer.type}-${modelConfig.tokenizer.name}`;
+      logger4.info("Loading tokenizer:", {
+        key: tokenizerKey,
+        name: modelConfig.tokenizer.name,
+        type: modelConfig.tokenizer.type,
+        modelsDir: this.modelsDir,
+        cacheDir: this.cacheDir
+      });
+      if (this.tokenizers.has(tokenizerKey)) {
+        logger4.info("Using cached tokenizer:", { key: tokenizerKey });
+        const cachedTokenizer = this.tokenizers.get(tokenizerKey);
+        if (!cachedTokenizer) {
+          throw new Error(`Tokenizer ${tokenizerKey} exists in map but returned undefined`);
+        }
+        return cachedTokenizer;
+      }
+      const fs3 = await import("fs");
+      if (!fs3.existsSync(this.modelsDir)) {
+        logger4.warn("Models directory does not exist, creating it:", this.modelsDir);
+        fs3.mkdirSync(this.modelsDir, { recursive: true });
+      }
+      logger4.info(
+        "Initializing new tokenizer from HuggingFace with models directory:",
+        this.modelsDir
+      );
+      try {
+        const tokenizer = await AutoTokenizer.from_pretrained(modelConfig.tokenizer.name, {
+          cache_dir: this.modelsDir,
+          local_files_only: false
+        });
+        this.tokenizers.set(tokenizerKey, tokenizer);
+        logger4.success("Tokenizer loaded successfully:", { key: tokenizerKey });
+        return tokenizer;
+      } catch (tokenizeError) {
+        logger4.error("Failed to load tokenizer from HuggingFace:", {
+          error: tokenizeError instanceof Error ? tokenizeError.message : String(tokenizeError),
+          stack: tokenizeError instanceof Error ? tokenizeError.stack : void 0,
+          tokenizer: modelConfig.tokenizer.name,
+          modelsDir: this.modelsDir
+        });
+        logger4.info("Retrying tokenizer loading...");
+        const tokenizer = await AutoTokenizer.from_pretrained(modelConfig.tokenizer.name, {
+          cache_dir: this.modelsDir,
+          local_files_only: false
+        });
+        this.tokenizers.set(tokenizerKey, tokenizer);
+        logger4.success("Tokenizer loaded successfully on retry:", {
+          key: tokenizerKey
+        });
+        return tokenizer;
+      }
+    } catch (error) {
+      logger4.error("Failed to load tokenizer:", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        model: modelConfig.name,
+        tokenizer: modelConfig.tokenizer.name,
+        modelsDir: this.modelsDir
+      });
+      throw error;
+    }
+  }
+  /**
+   * Encodes the given text using the specified tokenizer model configuration.
+   *
+   * @param {string} text - The text to encode.
+   * @param {ModelSpec} modelConfig - The configuration for the model tokenizer.
+   * @returns {Promise<number[]>} - An array of integers representing the encoded text.
+   * @throws {Error} - If the text encoding fails, an error is thrown.
+   */
+  async encode(text, modelConfig) {
+    try {
+      logger4.info("Encoding text with tokenizer:", {
+        length: text.length,
+        tokenizer: modelConfig.tokenizer.name
+      });
+      const tokenizer = await this.loadTokenizer(modelConfig);
+      logger4.info("Tokenizer loaded, encoding text...");
+      const encoded = await tokenizer.encode(text, {
+        add_special_tokens: true,
+        return_token_type_ids: false
+      });
+      logger4.info("Text encoded successfully:", {
+        tokenCount: encoded.length,
+        tokenizer: modelConfig.tokenizer.name
+      });
+      return encoded;
+    } catch (error) {
+      logger4.error("Text encoding failed:", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        textLength: text.length,
+        tokenizer: modelConfig.tokenizer.name,
+        modelsDir: this.modelsDir
+      });
+      throw error;
+    }
+  }
+  /**
+   * Asynchronously decodes an array of tokens using a tokenizer based on the provided ModelSpec.
+   *
+   * @param {number[]} tokens - The array of tokens to be decoded.
+   * @param {ModelSpec} modelConfig - The ModelSpec object containing information about the model and tokenizer to be used.
+   * @returns {Promise<string>} - A Promise that resolves with the decoded text.
+   * @throws {Error} - If an error occurs during token decoding.
+   */
+  async decode(tokens, modelConfig) {
+    try {
+      logger4.info("Decoding tokens with tokenizer:", {
+        count: tokens.length,
+        tokenizer: modelConfig.tokenizer.name
+      });
+      const tokenizer = await this.loadTokenizer(modelConfig);
+      logger4.info("Tokenizer loaded, decoding tokens...");
+      const decoded = await tokenizer.decode(tokens, {
+        skip_special_tokens: true,
+        clean_up_tokenization_spaces: true
+      });
+      logger4.info("Tokens decoded successfully:", {
+        textLength: decoded.length,
+        tokenizer: modelConfig.tokenizer.name
+      });
+      return decoded;
+    } catch (error) {
+      logger4.error("Token decoding failed:", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        tokenCount: tokens.length,
+        tokenizer: modelConfig.tokenizer.name,
+        modelsDir: this.modelsDir
+      });
+      throw error;
+    }
+  }
+};
+
+// src/index.ts
+var CORRUPTED_MODEL_ERROR_SIGNATURES = [
+  "data is not within the file bounds",
+  "failed to load model",
+  "model is corrupted",
+  "data of tensor",
+  "is out of bounds"
+];
+var CONTEXT_LIMIT_ERROR_SIGNATURES = [
+  "input is longer than the context size",
+  "context size",
+  "too many tokens",
+  "exceeds context"
+];
+var NODE_LLAMA_NOISY_LOAD_ERROR_PATTERNS = [
+  "llama_model_load:",
+  "llama_model_load_from_file_impl: failed to load model"
+];
+var MIN_EMBEDDING_RETRY_TEXT_LENGTH = 1;
+var EMBEDDING_MODEL_HINTS = [
+  {
+    pattern: /nomic-embed-text-v1\.5/i,
+    repo: "nomic-ai/nomic-embed-text-v1.5-GGUF",
+    dimensions: 768,
+    contextSize: 8192
+  },
+  {
+    pattern: /bge-small-en-v1\.5/i,
+    repo: "ChristianAzinn/bge-small-en-v1.5-gguf",
+    dimensions: 384,
+    contextSize: 512
+  },
+  {
+    pattern: /e5-mistral-7b/i,
+    repo: "dranger003/e5-mistral-7b-instruct-GGUF",
+    dimensions: 4096,
+    contextSize: 32768
+  }
+];
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return String(error);
+}
+function isCorruptedModelLoadError(error) {
+  const message = getErrorMessage(error).toLowerCase();
+  return CORRUPTED_MODEL_ERROR_SIGNATURES.some((signature) => message.includes(signature));
+}
+function isContextLimitError(error) {
+  const message = getErrorMessage(error).toLowerCase();
+  return CONTEXT_LIMIT_ERROR_SIGNATURES.some((signature) => message.includes(signature));
+}
+function shouldSuppressNodeLlamaLoadError(message) {
+  const lower = message.toLowerCase();
+  return NODE_LLAMA_NOISY_LOAD_ERROR_PATTERNS.some((pattern) => lower.includes(pattern));
+}
+function shrinkEmbeddingInput(text) {
+  if (text.length <= MIN_EMBEDDING_RETRY_TEXT_LENGTH) return text;
+  const nextLength = Math.max(MIN_EMBEDDING_RETRY_TEXT_LENGTH, Math.floor(text.length / 2));
+  return text.slice(0, nextLength);
+}
+function inferEmbeddingModelHint(modelName) {
+  const match = EMBEDDING_MODEL_HINTS.find((hint) => hint.pattern.test(modelName));
+  return match ?? null;
+}
+function resolveEmbeddingModelSpec(config, fallback) {
+  const modelName = config.LOCAL_EMBEDDING_MODEL || fallback.name;
+  const hint = inferEmbeddingModelHint(modelName);
+  return {
+    ...fallback,
+    name: modelName,
+    repo: config.LOCAL_EMBEDDING_MODEL_REPO?.trim() || hint?.repo || fallback.repo,
+    dimensions: config.LOCAL_EMBEDDING_DIMENSIONS ?? hint?.dimensions ?? fallback.dimensions,
+    contextSize: config.LOCAL_EMBEDDING_CONTEXT_SIZE ?? hint?.contextSize ?? fallback.contextSize
+  };
+}
+function readMagicHeader(filePath) {
+  try {
+    const fd = fs2.openSync(filePath, "r");
+    try {
+      const header = Buffer.alloc(4);
+      const bytesRead = fs2.readSync(fd, header, 0, header.length, 0);
+      return { bytesRead, magic: header.toString("ascii", 0, 4) };
+    } finally {
+      fs2.closeSync(fd);
+    }
+  } catch {
+    return { bytesRead: 0, magic: "" };
+  }
+}
+function isValidGgufFile(filePath) {
+  const { bytesRead, magic } = readMagicHeader(filePath);
+  return bytesRead === 4 && magic === "GGUF";
+}
+function safeUnlink(filePath) {
+  if (!filePath || !fs2.existsSync(filePath)) return;
+  try {
+    fs2.unlinkSync(filePath);
+  } catch (err) {
+    logger5.warn(
+      `Failed to remove model file ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+var LocalAIManager = class _LocalAIManager {
+  static instance = null;
+  llama;
+  embeddingModel;
+  embeddingContext;
+  modelPath;
+  mediumModelPath;
+  embeddingModelPath;
+  cacheDir;
+  tokenizerManager;
+  downloadManager;
+  activeModelConfig;
+  embeddingModelConfig;
+  config = null;
+  // Store validated config
+  // Initialization state flag
+  embeddingInitialized = false;
+  environmentInitialized = false;
+  // Add flag for environment initialization
+  // Initialization promises to prevent duplicate initialization
+  embeddingInitializingPromise = null;
+  environmentInitializingPromise = null;
+  // Add promise for environment
+  modelsDir;
+  /**
+   * Private constructor function to initialize base managers and paths.
+   * Model paths are set after environment initialization.
+   */
+  constructor() {
+    this.config = validateConfig();
+    this._setupCacheDir();
+    this.activeModelConfig = MODEL_SPECS.small;
+    this.embeddingModelConfig = MODEL_SPECS.embedding;
+  }
+  /**
+   * Post-validation initialization steps that require config to be set.
+   * Called after config validation in initializeEnvironment.
+   */
+  _postValidateInit() {
+    this._setupModelsDir();
+    this.downloadManager = DownloadManager.getInstance(this.cacheDir, this.modelsDir);
+    this.tokenizerManager = TokenizerManager.getInstance(this.cacheDir, this.modelsDir);
+  }
+  /**
+   * Sets up the models directory, reading from config or environment variables,
+   * and ensures the directory exists.
+   */
+  _setupModelsDir() {
+    const modelsDirEnv = this.config?.MODELS_DIR?.trim() || process.env.MODELS_DIR?.trim();
+    if (modelsDirEnv) {
+      this.modelsDir = path2.resolve(modelsDirEnv);
+      logger5.info("Using models directory from MODELS_DIR environment variable:", this.modelsDir);
+    } else {
+      this.modelsDir = path2.join(os2.homedir(), ".eliza", "models");
+      logger5.info(
+        "MODELS_DIR environment variable not set, using default models directory:",
+        this.modelsDir
+      );
+    }
+    if (!fs2.existsSync(this.modelsDir)) {
+      fs2.mkdirSync(this.modelsDir, { recursive: true });
+      logger5.debug("Ensured models directory exists (created):", this.modelsDir);
+    } else {
+      logger5.debug("Models directory already exists:", this.modelsDir);
+    }
+  }
+  /**
+   * Sets up the cache directory, reading from config or environment variables,
+   * and ensures the directory exists.
+   */
+  _setupCacheDir() {
+    const cacheDirEnv = this.config?.CACHE_DIR?.trim() || process.env.CACHE_DIR?.trim();
+    if (cacheDirEnv) {
+      this.cacheDir = path2.resolve(cacheDirEnv);
+      logger5.info("Using cache directory from CACHE_DIR environment variable:", this.cacheDir);
+    } else {
+      const cacheDir = path2.join(os2.homedir(), ".eliza", "cache");
+      if (!fs2.existsSync(cacheDir)) {
+        fs2.mkdirSync(cacheDir, { recursive: true });
+        logger5.debug("Ensuring cache directory exists (created):", cacheDir);
+      }
+      this.cacheDir = cacheDir;
+      logger5.info(
+        "CACHE_DIR environment variable not set, using default cache directory:",
+        this.cacheDir
+      );
+    }
+    if (!fs2.existsSync(this.cacheDir)) {
+      fs2.mkdirSync(this.cacheDir, { recursive: true });
+      logger5.debug("Ensured cache directory exists (created):", this.cacheDir);
+    } else {
+      logger5.debug("Cache directory already exists:", this.cacheDir);
+    }
+  }
+  /**
+   * Retrieves the singleton instance of LocalAIManager. If an instance does not already exist, a new one is created and returned.
+   * @returns {LocalAIManager} The singleton instance of LocalAIManager
+   */
+  static getInstance() {
+    if (!_LocalAIManager.instance) {
+      _LocalAIManager.instance = new _LocalAIManager();
+    }
+    return _LocalAIManager.instance;
+  }
+  /**
+   * Initializes the environment by validating the configuration and setting model paths.
+   * Now public to be callable from plugin init and model handlers.
+   *
+   * @returns {Promise<void>} A Promise that resolves once the environment has been successfully initialized.
+   */
+  async initializeEnvironment() {
+    if (this.environmentInitialized) return;
+    if (this.environmentInitializingPromise) {
+      await this.environmentInitializingPromise;
+      return;
+    }
+    this.environmentInitializingPromise = (async () => {
+      try {
+        logger5.info("Initializing environment configuration...");
+        this.config = await validateConfig();
+        this.embeddingModelConfig = resolveEmbeddingModelSpec(this.config, MODEL_SPECS.embedding);
+        this._postValidateInit();
+        this.embeddingModelPath = path2.join(this.modelsDir, this.embeddingModelConfig.name);
+        logger5.info("Using embedding model path:", basename(this.embeddingModelPath));
+        logger5.info(
+          {
+            model: this.embeddingModelConfig.name,
+            repo: this.embeddingModelConfig.repo,
+            dimensions: this.embeddingModelConfig.dimensions,
+            contextSize: this.embeddingModelConfig.contextSize
+          },
+          "Resolved embedding model spec"
+        );
+        this.ensureEmbeddingModelFileIsValid();
+        logger5.info("Environment configuration validated and model paths set");
+        this.environmentInitialized = true;
+        logger5.success("Environment initialization complete");
+      } catch (error) {
+        logger5.error(
+          {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0
+          },
+          "Environment validation failed"
+        );
+        this.environmentInitializingPromise = null;
+        throw error;
+      }
+    })();
+    await this.environmentInitializingPromise;
+  }
+  /**
+   * Downloads the model based on the modelPath provided.
+   * Determines the model spec and path based on the model type.
+   *
+   * @param {ModelTypeName} modelType - The type of model to download
+   * @param {ModelSpec} [customModelSpec] - Optional custom model spec to use instead of the default
+   * @returns A Promise that resolves to a boolean indicating whether the model download was successful.
+   */
+  async downloadModel(modelType, customModelSpec, forceDownload = false) {
+    let modelSpec;
+    let modelPathToDownload;
+    await this.initializeEnvironment();
+    if (customModelSpec) {
+      modelSpec = customModelSpec;
+      modelPathToDownload = modelType === ModelType.TEXT_EMBEDDING ? this.embeddingModelPath : modelType === ModelType.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
+    } else if (modelType === ModelType.TEXT_EMBEDDING) {
+      modelSpec = this.embeddingModelConfig;
+      modelPathToDownload = this.embeddingModelPath;
+      this.ensureEmbeddingModelFileIsValid();
+    } else {
+      modelSpec = modelType === ModelType.TEXT_LARGE ? MODEL_SPECS.medium : MODEL_SPECS.small;
+      modelPathToDownload = modelType === ModelType.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
+    }
+    try {
+      return await this.downloadManager.downloadModel(
+        modelSpec,
+        modelPathToDownload,
+        forceDownload
+      );
+    } catch (error) {
+      logger5.error(
+        {
+          error: error instanceof Error ? error.message : String(error),
+          modelType,
+          modelPath: modelPathToDownload
+        },
+        "Model download failed"
+      );
+      throw error;
+    }
+  }
+  /**
+   * Asynchronously checks the platform capabilities.
+   *
+   * @returns {Promise<void>} A promise that resolves once the platform capabilities have been checked.
+   */
+  async checkPlatformCapabilities() {
+    try {
+      const platformManager = getPlatformManager();
+      await platformManager.initialize();
+      const capabilities = platformManager.getCapabilities();
+      logger5.info(
+        {
+          platform: capabilities.platform,
+          gpu: capabilities.gpu?.type || "none",
+          recommendedModel: capabilities.recommendedModelSize,
+          supportedBackends: capabilities.supportedBackends
+        },
+        "Platform capabilities detected"
+      );
+    } catch (error) {
+      logger5.warn(error instanceof Error ? error : String(error), "Platform detection failed");
+    }
+  }
+  /**
+   * Initializes the LocalAI Manager for a given model type.
+   *
+   * @param {ModelTypeName} modelType - The type of model to initialize (default: ModelType.TEXT_SMALL)
+   * @returns {Promise<void>} A promise that resolves when initialization is complete or rejects if an error occurs
+   */
+  async initialize(_modelType = ModelType.TEXT_SMALL) {
+    await this.initializeEnvironment();
+  }
+  getEmbeddingDimensions() {
+    return this.embeddingModelConfig.dimensions;
+  }
+  ensureEmbeddingModelFileIsValid() {
+    if (!this.embeddingModelPath || !fs2.existsSync(this.embeddingModelPath)) return;
+    if (isValidGgufFile(this.embeddingModelPath)) return;
+    const { bytesRead, magic } = readMagicHeader(this.embeddingModelPath);
+    logger5.warn(
+      {
+        embeddingModelPath: this.embeddingModelPath,
+        bytesRead,
+        magic
+      },
+      "Invalid embedding model file detected; removing corrupt file before download/retry"
+    );
+    safeUnlink(this.embeddingModelPath);
+  }
+  async ensureLlama() {
+    if (this.llama) return;
+    this.llama = await getLlama({
+      logLevel: LlamaLogLevel.error,
+      logger: (level, message) => {
+        if (level !== "error" && level !== "fatal") return;
+        const text = message.trim();
+        if (!text) return;
+        if (shouldSuppressNodeLlamaLoadError(text)) return;
+        logger5.error(`[node-llama-cpp] ${text}`);
+      }
+    });
+  }
+  async loadEmbeddingModel() {
+    this.ensureEmbeddingModelFileIsValid();
+    const gpuLayers = this.config?.LOCAL_EMBEDDING_GPU_LAYERS === -1 ? "auto" : this.config?.LOCAL_EMBEDDING_GPU_LAYERS ?? 0;
+    const useMmap = this.config?.LOCAL_EMBEDDING_USE_MMAP ?? true;
+    this.embeddingModel = await this.llama.loadModel({
+      modelPath: this.embeddingModelPath,
+      gpuLayers,
+      vocabOnly: false,
+      useMmap
+    });
+    this.embeddingContext = await this.embeddingModel.createEmbeddingContext({
+      contextSize: this.embeddingModelConfig.contextSize,
+      batchSize: 512
+    });
+  }
+  async initializeEmbeddingWithRecovery() {
+    logger5.info("Loading embedding model:", this.embeddingModelPath);
+    try {
+      await this.loadEmbeddingModel();
+      logger5.success("Embedding model initialized successfully");
+      return;
+    } catch (error) {
+      if (!isCorruptedModelLoadError(error)) {
+        throw error;
+      }
+      logger5.warn(
+        {
+          error: getErrorMessage(error),
+          embeddingModelPath: this.embeddingModelPath
+        },
+        "Embedding model appears corrupted/incomplete; deleting and re-downloading"
+      );
+      this.embeddingModel = void 0;
+      this.embeddingContext = void 0;
+      safeUnlink(this.embeddingModelPath);
+      await this.downloadModel(ModelType.TEXT_EMBEDDING, void 0, true);
+      this.ensureEmbeddingModelFileIsValid();
+      await this.loadEmbeddingModel();
+      logger5.success("Embedding model recovered after re-download");
+    }
+  }
+  /**
+   * Asynchronously initializes the embedding model.
+   *
+   * @returns {Promise<void>} A promise that resolves once the initialization is complete.
+   */
+  async initializeEmbedding() {
+    try {
+      await this.initializeEnvironment();
+      logger5.info("Initializing embedding model...");
+      logger5.info("Models directory:", this.modelsDir);
+      if (!fs2.existsSync(this.modelsDir)) {
+        logger5.warn("Models directory does not exist, creating it:", this.modelsDir);
+        fs2.mkdirSync(this.modelsDir, { recursive: true });
+      }
+      await this.downloadModel(ModelType.TEXT_EMBEDDING);
+      this.ensureEmbeddingModelFileIsValid();
+      await this.ensureLlama();
+      if (!this.embeddingModel) {
+        await this.initializeEmbeddingWithRecovery();
+      }
+    } catch (error) {
+      if (isCorruptedModelLoadError(error)) {
+        logger5.warn(
+          {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0,
+            modelsDir: this.modelsDir,
+            embeddingModelPath: this.embeddingModelPath
+          },
+          "Embedding initialization failed due to model corruption"
+        );
+        safeUnlink(this.embeddingModelPath);
+      } else {
+        logger5.error(
+          {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0,
+            modelsDir: this.modelsDir,
+            embeddingModelPath: this.embeddingModelPath
+            // Log the path being used
+          },
+          "Embedding initialization failed with details"
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Generate embeddings using the proper LlamaContext.getEmbedding method.
+   */
+  async generateEmbedding(text) {
+    try {
+      await this.lazyInitEmbedding();
+      if (!this.embeddingModel || !this.embeddingContext) {
+        throw new Error("Failed to initialize embedding model");
+      }
+      logger5.info({ textLength: text.length }, "Generating embedding for text");
+      let candidateText = text;
+      let attempt = 0;
+      while (true) {
+        try {
+          const embeddingResult = await this.embeddingContext.getEmbeddingFor(candidateText);
+          const mutableEmbedding = [...embeddingResult.vector];
+          const sizedEmbedding = this.alignEmbeddingDimensions(mutableEmbedding);
+          const normalizedEmbedding = this.normalizeEmbedding(sizedEmbedding);
+          logger5.info({ dimensions: normalizedEmbedding.length }, "Embedding generation complete");
+          return normalizedEmbedding;
+        } catch (error) {
+          if (!isContextLimitError(error)) {
+            throw error;
+          }
+          const nextCandidate = shrinkEmbeddingInput(candidateText);
+          if (nextCandidate === candidateText) {
+            throw error;
+          }
+          attempt += 1;
+          logger5.warn(
+            {
+              attempt,
+              currentChars: candidateText.length,
+              nextChars: nextCandidate.length
+            },
+            "Embedding input exceeded context window; retrying with truncated text"
+          );
+          candidateText = nextCandidate;
+        }
+      }
+    } catch (error) {
+      if (isCorruptedModelLoadError(error)) {
+        logger5.warn(
+          {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0,
+            textLength: text?.length ?? "text is null",
+            embeddingModelPath: this.embeddingModelPath
+          },
+          "Embedding generation failed due to model corruption; model file removed"
+        );
+        safeUnlink(this.embeddingModelPath);
+        this.embeddingModel = void 0;
+        this.embeddingContext = void 0;
+        this.embeddingInitialized = false;
+      } else {
+        logger5.error(
+          {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0,
+            textLength: text?.length ?? "text is null"
+          },
+          "Embedding generation failed"
+        );
+      }
+      const zeroDimensions = this.getEmbeddingDimensions();
+      return new Array(zeroDimensions).fill(0);
+    }
+  }
+  /**
+   * Normalizes an embedding vector using L2 normalization
+   *
+   * @param {number[]} embedding - The embedding vector to normalize
+   * @returns {number[]} - The normalized embedding vector
+   */
+  alignEmbeddingDimensions(embedding) {
+    const targetDimensions = this.getEmbeddingDimensions();
+    if (targetDimensions <= 0 || embedding.length === targetDimensions) {
+      return embedding;
+    }
+    logger5.warn(
+      {
+        observedDimensions: embedding.length,
+        targetDimensions
+      },
+      "Embedding dimensions mismatch; adjusting output dimensions"
+    );
+    if (embedding.length > targetDimensions) {
+      return embedding.slice(0, targetDimensions);
+    }
+    return [...embedding, ...new Array(targetDimensions - embedding.length).fill(0)];
+  }
+  normalizeEmbedding(embedding) {
+    const squareSum = embedding.reduce((sum, val) => sum + val * val, 0);
+    const norm = Math.sqrt(squareSum);
+    if (norm === 0) {
+      return embedding;
+    }
+    return embedding.map((val) => val / norm);
+  }
+  /**
+   * Lazy initialize the embedding model
+   */
+  async lazyInitEmbedding() {
+    if (this.embeddingInitialized) return;
+    if (!this.embeddingInitializingPromise) {
+      this.embeddingInitializingPromise = (async () => {
+        try {
+          await this.initializeEnvironment();
+          await this.downloadModel(ModelType.TEXT_EMBEDDING);
+          this.ensureEmbeddingModelFileIsValid();
+          await this.ensureLlama();
+          await this.initializeEmbeddingWithRecovery();
+          this.embeddingInitialized = true;
+          logger5.info("Embedding model initialized successfully");
+        } catch (error) {
+          if (isCorruptedModelLoadError(error)) {
+            logger5.warn(
+              error instanceof Error ? error : String(error),
+              "Failed to initialize embedding model due to corruption"
+            );
+            safeUnlink(this.embeddingModelPath);
+          } else {
+            logger5.error(
+              error instanceof Error ? error : String(error),
+              "Failed to initialize embedding model"
+            );
+          }
+          this.embeddingInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.embeddingInitializingPromise;
+  }
+  /**
+   * Returns the TokenizerManager associated with this object.
+   *
+   * @returns {TokenizerManager} The TokenizerManager object.
+   */
+  getTokenizerManager() {
+    return this.tokenizerManager;
+  }
+  /**
+   * Returns the active model configuration.
+   * @returns {ModelSpec} The active model configuration.
+   */
+  getActiveModelConfig() {
+    return this.activeModelConfig;
+  }
+};
+var localAIManager = LocalAIManager.getInstance();
+var localAiPlugin = {
+  name: "local-ai",
+  description: "Local AI plugin using LLaMA models",
+  // Higher priority ensures local embeddings are used instead of remote
+  // providers (e.g. ElizaCloud, OpenAI) even when plugins register in
+  // parallel and the registration order is non-deterministic.
+  priority: 10,
+  async init(_config, _runtime) {
+    logger5.info("Initializing local embedding plugin...");
+    try {
+      await localAIManager.initializeEnvironment();
+      await localAIManager.checkPlatformCapabilities();
+      const config = validateConfig();
+      const modelsDir = config.MODELS_DIR || path2.join(os2.homedir(), ".eliza", "models");
+      const embeddingModelPath = path2.join(modelsDir, config.LOCAL_EMBEDDING_MODEL);
+      if (fs2.existsSync(embeddingModelPath)) {
+        logger5.info(
+          { embeddingModelPath: basename(embeddingModelPath) },
+          "Embedding model file is present"
+        );
+      } else {
+        logger5.info(
+          { embeddingModelPath: basename(embeddingModelPath) },
+          "Embedding model file not present yet; it will be downloaded on first use"
+        );
+      }
+      logger5.success("Local embedding plugin initialized");
+    } catch (error) {
+      logger5.error(
+        {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        },
+        "Failed to initialize local embedding plugin"
+      );
+      logger5.warn("Local embedding plugin may be unavailable");
+    }
+  },
+  models: {
+    [ModelType.TEXT_EMBEDDING]: async (_runtime, params) => {
+      let text;
+      if (typeof params === "string") {
+        text = params;
+      } else if (params && typeof params === "object" && "text" in params) {
+        text = params.text;
+      }
+      try {
+        if (!text) {
+          logger5.debug("Null or empty text input for embedding, returning zero vector");
+          return new Array(localAIManager.getEmbeddingDimensions()).fill(0);
+        }
+        return await localAIManager.generateEmbedding(text);
+      } catch (error) {
+        logger5.error(
+          {
+            error: error instanceof Error ? error.message : String(error),
+            fullText: text,
+            textType: typeof text,
+            textStructure: text !== null ? JSON.stringify(text, null, 2) : "null"
+          },
+          "Error in TEXT_EMBEDDING handler"
+        );
+        return new Array(localAIManager.getEmbeddingDimensions()).fill(0);
+      }
+    },
+    [ModelType.TEXT_TOKENIZER_ENCODE]: async (_runtime, params) => {
+      try {
+        const manager = localAIManager.getTokenizerManager();
+        const config = localAIManager.getActiveModelConfig();
+        return await manager.encode(params.prompt, config);
+      } catch (error) {
+        logger5.error(
+          error instanceof Error ? error : String(error),
+          "Error in TEXT_TOKENIZER_ENCODE handler"
+        );
+        throw error;
+      }
+    },
+    [ModelType.TEXT_TOKENIZER_DECODE]: async (_runtime, params) => {
+      try {
+        const manager = localAIManager.getTokenizerManager();
+        const config = localAIManager.getActiveModelConfig();
+        return await manager.decode(params.tokens, config);
+      } catch (error) {
+        logger5.error(
+          error instanceof Error ? error : String(error),
+          "Error in TEXT_TOKENIZER_DECODE handler"
+        );
+        throw error;
+      }
+    }
+  },
+  tests: [
+    {
+      name: "local_ai_plugin_tests",
+      tests: [
+        {
+          name: "local_ai_test_text_embedding",
+          fn: async (runtime) => {
+            try {
+              logger5.info("Starting TEXT_EMBEDDING test");
+              const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+                text: "This is a test of the text embedding model."
+              });
+              logger5.info({ count: embedding.length }, "Embedding generated with dimensions");
+              if (!Array.isArray(embedding)) {
+                throw new Error("Embedding is not an array");
+              }
+              if (embedding.length === 0) {
+                throw new Error("Embedding array is empty");
+              }
+              if (embedding.some((val) => typeof val !== "number")) {
+                throw new Error("Embedding contains non-numeric values");
+              }
+              const nullEmbedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, null);
+              if (!Array.isArray(nullEmbedding) || nullEmbedding.some((val) => val !== 0)) {
+                throw new Error("Null input did not return zero vector");
+              }
+              logger5.success("TEXT_EMBEDDING test completed successfully");
+            } catch (error) {
+              logger5.error(
+                {
+                  error: error instanceof Error ? error.message : String(error),
+                  stack: error instanceof Error ? error.stack : void 0
+                },
+                "TEXT_EMBEDDING test failed"
+              );
+              throw error;
+            }
+          }
+        },
+        {
+          name: "local_ai_test_tokenizer_encode",
+          fn: async (runtime) => {
+            try {
+              logger5.info("Starting TEXT_TOKENIZER_ENCODE test");
+              const prompt = "Hello tokenizer test!";
+              const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, {
+                prompt,
+                modelType: ModelType.TEXT_TOKENIZER_ENCODE
+              });
+              logger5.info({ count: tokens.length }, "Encoded tokens");
+              if (!Array.isArray(tokens)) {
+                throw new Error("Tokens output is not an array");
+              }
+              if (tokens.length === 0) {
+                throw new Error("No tokens generated");
+              }
+              if (tokens.some((token) => !Number.isInteger(token))) {
+                throw new Error("Tokens contain non-integer values");
+              }
+              logger5.success("TEXT_TOKENIZER_ENCODE test completed successfully");
+            } catch (error) {
+              logger5.error(
+                {
+                  error: error instanceof Error ? error.message : String(error),
+                  stack: error instanceof Error ? error.stack : void 0
+                },
+                "TEXT_TOKENIZER_ENCODE test failed"
+              );
+              throw error;
+            }
+          }
+        },
+        {
+          name: "local_ai_test_tokenizer_decode",
+          fn: async (runtime) => {
+            try {
+              logger5.info("Starting TEXT_TOKENIZER_DECODE test");
+              const originalText = "Hello tokenizer test!";
+              const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, {
+                prompt: originalText,
+                modelType: ModelType.TEXT_TOKENIZER_ENCODE
+              });
+              const decodedText = await runtime.useModel(ModelType.TEXT_TOKENIZER_DECODE, {
+                tokens,
+                modelType: ModelType.TEXT_TOKENIZER_DECODE
+              });
+              logger5.info(
+                { original: originalText, decoded: decodedText },
+                "Round trip tokenization"
+              );
+              if (typeof decodedText !== "string") {
+                throw new Error("Decoded output is not a string");
+              }
+              logger5.success("TEXT_TOKENIZER_DECODE test completed successfully");
+            } catch (error) {
+              logger5.error(
+                {
+                  error: error instanceof Error ? error.message : String(error),
+                  stack: error instanceof Error ? error.stack : void 0
+                },
+                "TEXT_TOKENIZER_DECODE test failed"
+              );
+              throw error;
+            }
+          }
+        }
+      ]
+    }
+  ]
+};
+var index_default = localAiPlugin;
+export {
+  index_default as default,
+  localAiPlugin
+};
+//# sourceMappingURL=index.js.map