@elizaos/plugin-local-embedding 2.0.0-alpha.6 → 2.0.0-alpha.8

package/dist/index.js

@@ -4,6 +4,7 @@ import {
   logger as logger5
 } from "@elizaos/core";
 import {
+  LlamaLogLevel,
   getLlama
 } from "node-llama-cpp";
 import fs2 from "fs";
@@ -17,44 +18,73 @@ 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().default("384").transform((val) => parseInt(val, 10))
-  // Transform to number
+  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
+      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("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
-    });
+    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("Using local AI configuration:", validatedConfig);
+    logger.info(validatedConfig, "Using local AI configuration:");
     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);
+      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("Configuration validation failed:", {
-      error: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : void 0
-    });
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      },
+      "Configuration validation failed:"
+    );
     throw error;
   }
 }
@@ -147,6 +177,11 @@ 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;
@@ -243,10 +278,10 @@ var DownloadManager = class _DownloadManager {
             reject(new Error(`Failed to download: ${response.statusCode}`));
             return;
           }
-          const totalSize = Number.parseInt(
-            response.headers["content-length"] || "0",
-            10
+          const expectedBytes = parseContentLength(
+            response.headers["content-length"]
           );
+          const totalSize = expectedBytes ?? 0;
           let downloadedSize = 0;
           let lastLoggedPercent = 0;
           const barLength = 30;
@@ -255,6 +290,7 @@ var DownloadManager = class _DownloadManager {
           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(
@@ -283,6 +319,18 @@ var DownloadManager = class _DownloadManager {
                   );
                   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`;
@@ -442,7 +490,7 @@ var DownloadManager = class _DownloadManager {
    * @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) {
+  async downloadModel(modelSpec, modelPath, forceDownload = false) {
     try {
       logger2.info("Starting local model download...");
       const modelDir = path.dirname(modelPath);
@@ -450,7 +498,21 @@ var DownloadManager = class _DownloadManager {
         logger2.info("Creating model directory:", modelDir);
         fs.mkdirSync(modelDir, { recursive: true });
       }
-      if (!fs.existsSync(modelPath)) {
+      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",
@@ -1063,6 +1125,118 @@ var TokenizerManager = class _TokenizerManager {
 };
 
 // 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;
@@ -1198,15 +1372,29 @@ var LocalAIManager = class _LocalAIManager {
       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.config.LOCAL_EMBEDDING_MODEL
+          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");
@@ -1232,7 +1420,7 @@ var LocalAIManager = class _LocalAIManager {
    * @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) {
+  async downloadModel(modelType, customModelSpec, forceDownload = false) {
     let modelSpec;
     let modelPathToDownload;
     await this.initializeEnvironment();
@@ -1240,8 +1428,9 @@ var LocalAIManager = class _LocalAIManager {
       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;
+      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;
@@ -1249,7 +1438,8 @@ var LocalAIManager = class _LocalAIManager {
     try {
       return await this.downloadManager.downloadModel(
         modelSpec,
-        modelPathToDownload
+        modelPathToDownload,
+        forceDownload
       );
     } catch (error) {
       logger5.error(
@@ -1298,6 +1488,78 @@ var LocalAIManager = class _LocalAIManager {
   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.
    *
@@ -1316,35 +1578,35 @@ var LocalAIManager = class _LocalAIManager {
         fs2.mkdirSync(this.modelsDir, { recursive: true });
       }
       await this.downloadModel(ModelType.TEXT_EMBEDDING);
-      if (!this.llama) {
-        this.llama = await getLlama();
-      }
+      this.ensureEmbeddingModelFileIsValid();
+      await this.ensureLlama();
       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");
+        await this.initializeEmbeddingWithRecovery();
       }
     } 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"
-      );
+      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;
     }
   }
@@ -1358,24 +1620,69 @@ var LocalAIManager = class _LocalAIManager {
         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;
+      let candidateText = text;
+      let attempt = 0;
+      while (true) {
+        try {
+          const embeddingResult = await this.embeddingContext.getEmbeddingFor(candidateText);
+          logger5.info({
+            hasResult: !!embeddingResult,
+            hasVector: !!embeddingResult?.vector
+          }, "Debug: embeddingResult");
+          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) {
-      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;
+      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);
     }
   }
@@ -1385,6 +1692,26 @@ var LocalAIManager = class _LocalAIManager {
    * @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);
@@ -1403,26 +1730,24 @@ var LocalAIManager = class _LocalAIManager {
         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.ensureEmbeddingModelFileIsValid();
+          await this.ensureLlama();
+          await this.initializeEmbeddingWithRecovery();
           this.embeddingInitialized = true;
           logger5.info("Embedding model initialized successfully");
         } catch (error) {
-          logger5.error(
-            error instanceof Error ? error : String(error),
-            "Failed to initialize embedding model"
-          );
+          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;
         }
@@ -1454,85 +1779,38 @@ var localAiPlugin = {
   // 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("\u{1F680} Initializing Local AI plugin...");
+  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");
-      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 embeddingModelPath = path2.join(
+        modelsDir,
+        config.LOCAL_EMBEDDING_MODEL
+      );
+      if (fs2.existsSync(embeddingModelPath)) {
+        logger5.info(
+          { embeddingModelPath: basename(embeddingModelPath) },
+          "Embedding model file is present"
         );
-        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"
+      } else {
+        logger5.info(
+          { embeddingModelPath: basename(embeddingModelPath) },
+          "Embedding model file not present yet; it will be downloaded on first use"
         );
-        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");
       }
+      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
         },
-        "\u274C Failed to initialize Local AI plugin"
+        "Failed to initialize local embedding 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");
+      logger5.warn("Local embedding plugin may be unavailable");
     }
   },
   models: {
@@ -1548,7 +1826,7 @@ var localAiPlugin = {
           logger5.debug(
             "Null or empty text input for embedding, returning zero vector"
           );
-          return new Array(384).fill(0);
+          return new Array(localAIManager.getEmbeddingDimensions()).fill(0);
         }
         return await localAIManager.generateEmbedding(text);
       } catch (error) {
@@ -1561,7 +1839,7 @@ var localAiPlugin = {
           },
           "Error in TEXT_EMBEDDING handler"
         );
-        return new Array(384).fill(0);
+        return new Array(localAIManager.getEmbeddingDimensions()).fill(0);
       }
     },
     [ModelType.TEXT_TOKENIZER_ENCODE]: async (_runtime, params) => {