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

package/dist/index.js

@@ -0,0 +1,1727 @@
+// src/index.ts
+import {
+  ModelType,
+  logger as logger5
+} from "@elizaos/core";
+import {
+  getLlama
+} from "node-llama-cpp";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+import { basename } from "path";
+
+// 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),
+  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().default("384").transform((val) => parseInt(val, 10))
+  // Transform to number
+});
+function validateConfig() {
+  try {
+    const configToParse = {
+      LOCAL_EMBEDDING_MODEL: process.env.LOCAL_EMBEDDING_MODEL,
+      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
+    };
+    logger.debug("Validating configuration for local AI plugin from env:", {
+      LOCAL_EMBEDDING_MODEL: configToParse.LOCAL_EMBEDDING_MODEL,
+      MODELS_DIR: configToParse.MODELS_DIR,
+      CACHE_DIR: configToParse.CACHE_DIR,
+      LOCAL_EMBEDDING_DIMENSIONS: configToParse.LOCAL_EMBEDDING_DIMENSIONS
+    });
+    const validatedConfig = configSchema.parse(configToParse);
+    logger.info("Using local AI configuration:", validatedConfig);
+    return validatedConfig;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n");
+      logger.error("Zod validation failed:", errorMessages);
+      throw new Error(`Configuration validation failed:
+${errorMessages}`);
+    }
+    logger.error("Configuration validation failed:", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    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";
+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 totalSize = Number.parseInt(
+            response.headers["content-length"] || "0",
+            10
+          );
+          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;
+            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 (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) {
+    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)) {
+        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);
+        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);
+        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 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._postValidateInit();
+        this.embeddingModelPath = path2.join(
+          this.modelsDir,
+          this.config.LOCAL_EMBEDDING_MODEL
+        );
+        logger5.info(
+          "Using embedding model path:",
+          basename(this.embeddingModelPath)
+        );
+        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) {
+    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 = MODEL_SPECS.embedding;
+      modelPathToDownload = this.embeddingModelPath;
+    } 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
+      );
+    } 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();
+  }
+  /**
+   * 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);
+      if (!this.llama) {
+        this.llama = await getLlama();
+      }
+      if (!this.embeddingModel) {
+        logger5.info("Loading embedding model:", this.embeddingModelPath);
+        this.embeddingModel = await this.llama.loadModel({
+          modelPath: this.embeddingModelPath,
+          // Use the correct path
+          gpuLayers: 0,
+          // Embedding models are typically small enough to run on CPU
+          vocabOnly: false
+        });
+        this.embeddingContext = await this.embeddingModel.createEmbeddingContext({
+          contextSize: this.embeddingModelConfig.contextSize,
+          batchSize: 512
+        });
+        logger5.success("Embedding model initialized successfully");
+      }
+    } catch (error) {
+      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");
+      const embeddingResult = await this.embeddingContext.getEmbeddingFor(text);
+      const mutableEmbedding = [...embeddingResult.vector];
+      const normalizedEmbedding = this.normalizeEmbedding(mutableEmbedding);
+      logger5.info(
+        { dimensions: normalizedEmbedding.length },
+        "Embedding generation complete"
+      );
+      return normalizedEmbedding;
+    } catch (error) {
+      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.config?.LOCAL_EMBEDDING_DIMENSIONS ? this.config.LOCAL_EMBEDDING_DIMENSIONS : this.embeddingModelConfig.dimensions;
+      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
+   */
+  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);
+          if (!this.llama) {
+            this.llama = await getLlama();
+          }
+          this.embeddingModel = await this.llama.loadModel({
+            modelPath: this.embeddingModelPath,
+            gpuLayers: 0,
+            // Embedding models are typically small enough to run on CPU
+            vocabOnly: false
+          });
+          this.embeddingContext = await this.embeddingModel.createEmbeddingContext({
+            contextSize: this.embeddingModelConfig.contextSize,
+            batchSize: 512
+          });
+          this.embeddingInitialized = true;
+          logger5.info("Embedding model initialized successfully");
+        } catch (error) {
+          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",
+  async init(_config, runtime) {
+    logger5.info("\u{1F680} Initializing Local AI plugin...");
+    try {
+      await localAIManager.initializeEnvironment();
+      const config = validateConfig();
+      const modelsDir = config.MODELS_DIR || path2.join(os2.homedir(), ".eliza", "models");
+      if (!fs2.existsSync(modelsDir)) {
+        logger5.warn(`\u26A0\uFE0F Models directory does not exist: ${modelsDir}`);
+        logger5.warn(
+          "The directory will be created, but you need to download model files"
+        );
+        logger5.warn(
+          "Visit https://huggingface.co/models to download compatible GGUF models"
+        );
+      }
+      logger5.info("\u{1F50D} Testing Local AI initialization...");
+      try {
+        await localAIManager.checkPlatformCapabilities();
+        const llamaInstance = await getLlama();
+        if (llamaInstance) {
+          logger5.success("\u2705 Local AI: llama.cpp library loaded successfully");
+        } else {
+          throw new Error("Failed to load llama.cpp library");
+        }
+        const embeddingModelPath = path2.join(
+          modelsDir,
+          config.LOCAL_EMBEDDING_MODEL
+        );
+        const modelsExist = {
+          embedding: fs2.existsSync(embeddingModelPath)
+        };
+        if (!modelsExist.embedding) {
+          logger5.warn("\u26A0\uFE0F No model files found in models directory");
+          logger5.warn(
+            "Models will be downloaded on first use, which may take time"
+          );
+          logger5.warn(
+            "To pre-download models, run the plugin and it will fetch them automatically"
+          );
+        } else {
+          logger5.info(
+            { embedding: modelsExist.embedding ? "\u2713" : "\u2717" },
+            "\u{1F4E6} Found model files"
+          );
+        }
+        logger5.success("\u2705 Local AI plugin initialized successfully");
+        logger5.info("\u{1F4A1} Models will be loaded on-demand when first used");
+      } catch (testError) {
+        logger5.error(
+          testError instanceof Error ? testError : String(testError),
+          "\u274C Local AI initialization test failed"
+        );
+        logger5.warn("The plugin may not function correctly");
+        logger5.warn("Please check:");
+        logger5.warn("1. Your system has sufficient memory (8GB+ recommended)");
+        logger5.warn("2. C++ build tools are installed (for node-llama-cpp)");
+        logger5.warn("3. Your CPU supports the required instruction sets");
+      }
+    } catch (error) {
+      logger5.error(
+        {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        },
+        "\u274C Failed to initialize Local AI plugin"
+      );
+      if (error instanceof Error) {
+        if (error.message.includes("Cannot find module")) {
+          logger5.error("\u{1F4DA} Missing dependencies detected");
+          logger5.error("Please run: npm install or bun install");
+        } else if (error.message.includes("node-llama-cpp")) {
+          logger5.error("\u{1F527} node-llama-cpp build issue detected");
+          logger5.error("Please ensure C++ build tools are installed:");
+          logger5.error("- Windows: Install Visual Studio Build Tools");
+          logger5.error("- macOS: Install Xcode Command Line Tools");
+          logger5.error("- Linux: Install build-essential package");
+        }
+      }
+      logger5.warn("\u26A0\uFE0F Local AI plugin will not be available");
+    }
+  },
+  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(384).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(384).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