@elizaos/plugin-local-ai 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/index.js

@@ -5,411 +5,97 @@ import {
 } from "./chunk-TIOOHHYI.js";
 
 // src/index.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { Readable as Readable2 } from "node:stream";
+import { fileURLToPath } from "node:url";
 import {
-  logger as logger10,
-  ModelTypes as ModelTypes3
+  ModelTypes as ModelTypes3,
+  logger as logger10
 } from "@elizaos/core";
 import { EmbeddingModel, FlagEmbedding } from "fastembed";
 import {
-  getLlama as getLlama2,
-  LlamaChatSession
+  LlamaChatSession,
+  getLlama as getLlama2
 } from "node-llama-cpp";
-import path5 from "node:path";
-import { Readable as Readable2 } from "node:stream";
-import { fileURLToPath } from "node:url";
-import fs5 from "node:fs";
 
-// src/utils/platform.ts
+// src/environment.ts
 import { logger } from "@elizaos/core";
-import os from "node:os";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-var execAsync = promisify(exec);
-var PlatformManager = class _PlatformManager {
-  static instance;
-  capabilities = null;
-  constructor() {
-  }
-  static getInstance() {
-    if (!_PlatformManager.instance) {
-      _PlatformManager.instance = new _PlatformManager();
-    }
-    return _PlatformManager.instance;
+import { z } from "zod";
+var configSchema = z.object({
+  USE_LOCAL_AI: z.boolean().default(true),
+  USE_STUDIOLM_TEXT_MODELS: z.boolean().default(false),
+  USE_OLLAMA_TEXT_MODELS: z.boolean().default(false),
+  // Ollama Configuration
+  OLLAMA_SERVER_URL: z.string().default("http://localhost:11434"),
+  OLLAMA_MODEL: z.string().default("deepseek-r1-distill-qwen-7b"),
+  USE_OLLAMA_EMBEDDING: z.boolean().default(false),
+  OLLAMA_EMBEDDING_MODEL: z.string().default(""),
+  SMALL_OLLAMA_MODEL: z.string().default("deepseek-r1:1.5b"),
+  MEDIUM_OLLAMA_MODEL: z.string().default("deepseek-r1:7b"),
+  LARGE_OLLAMA_MODEL: z.string().default("deepseek-r1:7b"),
+  // StudioLM Configuration
+  STUDIOLM_SERVER_URL: z.string().default("http://localhost:1234"),
+  STUDIOLM_SMALL_MODEL: z.string().default("lmstudio-community/deepseek-r1-distill-qwen-1.5b"),
+  STUDIOLM_MEDIUM_MODEL: z.string().default("deepseek-r1-distill-qwen-7b"),
+  STUDIOLM_EMBEDDING_MODEL: z.union([z.boolean(), z.string()]).default(false)
+});
+function validateModelConfig(config) {
+  logger.info("Validating model configuration with values:", {
+    USE_LOCAL_AI: config.USE_LOCAL_AI,
+    USE_STUDIOLM_TEXT_MODELS: config.USE_STUDIOLM_TEXT_MODELS,
+    USE_OLLAMA_TEXT_MODELS: config.USE_OLLAMA_TEXT_MODELS
+  });
+  if (!config.USE_LOCAL_AI) {
+    config.USE_LOCAL_AI = true;
+    logger.info("Setting USE_LOCAL_AI to true as it's required");
   }
-  async initialize() {
-    try {
-      logger.info("Initializing platform detection...");
-      this.capabilities = await this.detectSystemCapabilities();
-    } catch (error) {
-      logger.error("Platform detection failed", { error });
-      throw error;
-    }
+  if (config.USE_STUDIOLM_TEXT_MODELS && config.USE_OLLAMA_TEXT_MODELS) {
+    throw new Error(
+      "StudioLM and Ollama text models cannot be enabled simultaneously"
+    );
   }
-  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
+  logger.info("Configuration is valid");
+}
+async function validateConfig(config) {
+  try {
+    const booleanConfig = {
+      USE_LOCAL_AI: true,
+      // Always true
+      USE_STUDIOLM_TEXT_MODELS: config.USE_STUDIOLM_TEXT_MODELS === "true",
+      USE_OLLAMA_TEXT_MODELS: config.USE_OLLAMA_TEXT_MODELS === "true",
+      USE_OLLAMA_EMBEDDING: config.USE_OLLAMA_EMBEDDING === "true"
     };
-  }
-  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
-      }
+    validateModelConfig(booleanConfig);
+    const fullConfig = {
+      ...booleanConfig,
+      OLLAMA_SERVER_URL: config.OLLAMA_SERVER_URL || "http://localhost:11434",
+      OLLAMA_MODEL: config.OLLAMA_MODEL || "deepseek-r1-distill-qwen-7b",
+      OLLAMA_EMBEDDING_MODEL: config.OLLAMA_EMBEDDING_MODEL || "",
+      SMALL_OLLAMA_MODEL: config.SMALL_OLLAMA_MODEL || "deepseek-r1:1.5b",
+      MEDIUM_OLLAMA_MODEL: config.MEDIUM_OLLAMA_MODEL || "deepseek-r1:7b",
+      LARGE_OLLAMA_MODEL: config.LARGE_OLLAMA_MODEL || "deepseek-r1:7b",
+      STUDIOLM_SERVER_URL: config.STUDIOLM_SERVER_URL || "http://localhost:1234",
+      STUDIOLM_SMALL_MODEL: config.STUDIOLM_SMALL_MODEL || "lmstudio-community/deepseek-r1-distill-qwen-1.5b",
+      STUDIOLM_MEDIUM_MODEL: config.STUDIOLM_MEDIUM_MODEL || "deepseek-r1-distill-qwen-7b",
+      STUDIOLM_EMBEDDING_MODEL: config.STUDIOLM_EMBEDDING_MODEL || false
     };
-  }
-  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) {
-      logger.error("GPU detection failed", { error });
-      return null;
-    }
-  }
-  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) {
-      logger.error("Mac GPU detection failed", { error });
-      return {
-        name: "Unknown Mac GPU",
-        type: "metal",
-        isAppleSilicon: false
-      };
-    }
-  }
-  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) {
-      logger.error("Windows GPU detection failed", { error });
-      return null;
-    }
-  }
-  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) {
-        logger.error("Linux GPU detection failed", { error });
-        return null;
-      }
-    }
-    return null;
-  }
-  async getNvidiaDriverVersion() {
-    try {
-      const { stdout } = await execAsync(
-        "nvidia-smi --query-gpu=driver_version --format=csv,noheader"
-      );
-      return stdout.trim();
-    } catch {
-      return "unknown";
-    }
-  }
-  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;
-  }
-  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";
-  }
-  getCapabilities() {
-    if (!this.capabilities) {
-      throw new Error("PlatformManager not initialized");
-    }
-    return this.capabilities;
-  }
-  isAppleSilicon() {
-    return !!this.capabilities?.gpu?.isAppleSilicon;
-  }
-  hasGPUSupport() {
-    return !!this.capabilities?.gpu;
-  }
-  supportsCUDA() {
-    return this.capabilities?.gpu?.type === "cuda";
-  }
-  supportsMetal() {
-    return this.capabilities?.gpu?.type === "metal";
-  }
-  supportsDirectML() {
-    return this.capabilities?.gpu?.type === "directml";
-  }
-  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 {
-  AutoTokenizer
-} from "@huggingface/transformers";
-import { logger as logger2 } from "@elizaos/core";
-var TokenizerManager = class _TokenizerManager {
-  static instance = null;
-  tokenizers;
-  cacheDir;
-  modelsDir;
-  constructor(cacheDir, modelsDir) {
-    this.tokenizers = /* @__PURE__ */ new Map();
-    this.cacheDir = cacheDir;
-    this.modelsDir = modelsDir;
-  }
-  static getInstance(cacheDir, modelsDir) {
-    if (!_TokenizerManager.instance) {
-      _TokenizerManager.instance = new _TokenizerManager(cacheDir, modelsDir);
-    }
-    return _TokenizerManager.instance;
-  }
-  async loadTokenizer(modelConfig) {
-    try {
-      const tokenizerKey = `${modelConfig.tokenizer.type}-${modelConfig.tokenizer.name}`;
-      logger2.info("Loading tokenizer:", {
-        key: tokenizerKey,
-        name: modelConfig.tokenizer.name,
-        type: modelConfig.tokenizer.type,
-        modelsDir: this.modelsDir,
-        cacheDir: this.cacheDir
-      });
-      if (this.tokenizers.has(tokenizerKey)) {
-        logger2.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 fs6 = await import("node:fs");
-      if (!fs6.existsSync(this.modelsDir)) {
-        logger2.warn(
-          "Models directory does not exist, creating it:",
-          this.modelsDir
-        );
-        fs6.mkdirSync(this.modelsDir, { recursive: true });
-      }
-      logger2.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);
-        logger2.success("Tokenizer loaded successfully:", { key: tokenizerKey });
-        return tokenizer;
-      } catch (tokenizeError) {
-        logger2.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
-        });
-        logger2.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);
-        logger2.success("Tokenizer loaded successfully on retry:", {
-          key: tokenizerKey
-        });
-        return tokenizer;
-      }
-    } catch (error) {
-      logger2.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;
-    }
-  }
-  async encode(text, modelConfig) {
-    try {
-      logger2.info("Encoding text with tokenizer:", {
-        length: text.length,
-        tokenizer: modelConfig.tokenizer.name
-      });
-      const tokenizer = await this.loadTokenizer(modelConfig);
-      logger2.info("Tokenizer loaded, encoding text...");
-      const encoded = await tokenizer.encode(text, {
-        add_special_tokens: true,
-        return_token_type_ids: false
-      });
-      logger2.info("Text encoded successfully:", {
-        tokenCount: encoded.length,
-        tokenizer: modelConfig.tokenizer.name
-      });
-      return encoded;
-    } catch (error) {
-      logger2.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;
-    }
-  }
-  async decode(tokens, modelConfig) {
-    try {
-      logger2.info("Decoding tokens with tokenizer:", {
-        count: tokens.length,
-        tokenizer: modelConfig.tokenizer.name
-      });
-      const tokenizer = await this.loadTokenizer(modelConfig);
-      logger2.info("Tokenizer loaded, decoding tokens...");
-      const decoded = await tokenizer.decode(tokens, {
-        skip_special_tokens: true,
-        clean_up_tokenization_spaces: true
-      });
-      logger2.info("Tokens decoded successfully:", {
-        textLength: decoded.length,
-        tokenizer: modelConfig.tokenizer.name
-      });
-      return decoded;
-    } catch (error) {
-      logger2.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;
+    const validatedConfig = configSchema.parse(fullConfig);
+    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 = {
@@ -574,52 +260,79 @@ var MODEL_SPECS = {
 };
 
 // src/utils/downloadManager.ts
-import { logger as logger3 } from "@elizaos/core";
 import fs from "node:fs";
 import https from "node:https";
 import path from "node: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() {
-    logger3.info("Ensuring cache directory exists:", this.cacheDir);
+    logger2.info("Ensuring cache directory exists:", this.cacheDir);
     if (!fs.existsSync(this.cacheDir)) {
       fs.mkdirSync(this.cacheDir, { recursive: true });
-      logger3.info("Created cache directory");
+      logger2.info("Created cache directory");
     }
   }
+  /**
+   * Ensure that the models directory exists. If it does not exist, create it.
+   */
   ensureModelsDirectory() {
-    logger3.info("Ensuring models directory exists:", this.modelsDir);
+    logger2.info("Ensuring models directory exists:", this.modelsDir);
     if (!fs.existsSync(this.modelsDir)) {
       fs.mkdirSync(this.modelsDir, { recursive: true });
-      logger3.info("Created models directory");
+      logger2.info("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) => {
-      logger3.info(`Starting download to: ${destPath}`);
+      logger2.info(`Starting download to: ${destPath}`);
       const tempPath = `${destPath}.tmp`;
       if (fs.existsSync(tempPath)) {
         try {
-          logger3.warn(`Removing existing temporary file: ${tempPath}`);
+          logger2.warn(`Removing existing temporary file: ${tempPath}`);
           fs.unlinkSync(tempPath);
         } catch (err) {
-          logger3.error(
+          logger2.error(
             `Failed to remove existing temporary file: ${err instanceof Error ? err.message : String(err)}`
           );
         }
@@ -656,7 +369,7 @@ var DownloadManager = class _DownloadManager {
           let lastLoggedPercent = 0;
           const barLength = 30;
           const fileName = path.basename(destPath);
-          logger3.info(`Downloading ${fileName}: ${"\u25B1".repeat(barLength)} 0%`);
+          logger2.info(`Downloading ${fileName}: ${"\u25B1".repeat(barLength)} 0%`);
           const file = fs.createWriteStream(tempPath);
           response.on("data", (chunk) => {
             downloadedSize += chunk.length;
@@ -666,7 +379,7 @@ var DownloadManager = class _DownloadManager {
                 downloadedSize / totalSize * barLength
               );
               const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger3.info(
+              logger2.info(
                 `Downloading ${fileName}: ${progressBar} ${percent}%`
               );
               lastLoggedPercent = percent;
@@ -677,7 +390,7 @@ var DownloadManager = class _DownloadManager {
             file.close(() => {
               try {
                 const completedBar = "\u25B0".repeat(barLength);
-                logger3.info(`Downloading ${fileName}: ${completedBar} 100%`);
+                logger2.info(`Downloading ${fileName}: ${completedBar} 100%`);
                 const destDir = path.dirname(destPath);
                 if (!fs.existsSync(destDir)) {
                   fs.mkdirSync(destDir, { recursive: true });
@@ -692,29 +405,29 @@ var DownloadManager = class _DownloadManager {
                   try {
                     const backupPath = `${destPath}.bak`;
                     fs.renameSync(destPath, backupPath);
-                    logger3.info(
+                    logger2.info(
                       `Created backup of existing file: ${backupPath}`
                     );
                     fs.renameSync(tempPath, destPath);
                     if (fs.existsSync(backupPath)) {
                       fs.unlinkSync(backupPath);
-                      logger3.info(
+                      logger2.info(
                         `Removed backup file after successful update: ${backupPath}`
                       );
                     }
                   } catch (moveErr) {
-                    logger3.error(
+                    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);
-                        logger3.info(
+                        logger2.info(
                           `Restored from backup after failed update: ${backupPath}`
                         );
                       } catch (restoreErr) {
-                        logger3.error(
+                        logger2.error(
                           `Failed to restore from backup: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`
                         );
                       }
@@ -723,7 +436,7 @@ var DownloadManager = class _DownloadManager {
                       try {
                         fs.unlinkSync(tempPath);
                       } catch (unlinkErr) {
-                        logger3.error(
+                        logger2.error(
                           `Failed to clean up temp file: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
                         );
                       }
@@ -734,20 +447,20 @@ var DownloadManager = class _DownloadManager {
                 } else {
                   fs.renameSync(tempPath, destPath);
                 }
-                logger3.success(
+                logger2.success(
                   `Download of ${fileName} completed successfully`
                 );
                 this.activeDownloads.delete(destPath);
                 resolve();
               } catch (err) {
-                logger3.error(
+                logger2.error(
                   `Error finalizing download: ${err instanceof Error ? err.message : String(err)}`
                 );
                 if (fs.existsSync(tempPath)) {
                   try {
                     fs.unlinkSync(tempPath);
                   } catch (unlinkErr) {
-                    logger3.error(
+                    logger2.error(
                       `Failed to clean up temp file: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
                     );
                   }
@@ -758,7 +471,7 @@ var DownloadManager = class _DownloadManager {
             });
           });
           file.on("error", (err) => {
-            logger3.error(
+            logger2.error(
               `File write error: ${err instanceof Error ? err.message : String(err)}`
             );
             file.close(() => {
@@ -766,7 +479,7 @@ var DownloadManager = class _DownloadManager {
                 try {
                   fs.unlinkSync(tempPath);
                 } catch (unlinkErr) {
-                  logger3.error(
+                  logger2.error(
                     `Failed to clean up temp file after error: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
                   );
                 }
@@ -778,14 +491,14 @@ var DownloadManager = class _DownloadManager {
         }
       );
       request.on("error", (err) => {
-        logger3.error(
+        logger2.error(
           `Request error: ${err instanceof Error ? err.message : String(err)}`
         );
         if (fs.existsSync(tempPath)) {
           try {
             fs.unlinkSync(tempPath);
           } catch (unlinkErr) {
-            logger3.error(
+            logger2.error(
               `Failed to clean up temp file after request error: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
             );
           }
@@ -794,13 +507,13 @@ var DownloadManager = class _DownloadManager {
         reject(err);
       });
       request.on("timeout", () => {
-        logger3.error("Download timeout occurred");
+        logger2.error("Download timeout occurred");
         request.destroy();
         if (fs.existsSync(tempPath)) {
           try {
             fs.unlinkSync(tempPath);
           } catch (unlinkErr) {
-            logger3.error(
+            logger2.error(
               `Failed to clean up temp file after timeout: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`
             );
           }
@@ -810,16 +523,23 @@ var DownloadManager = class _DownloadManager {
       });
     });
   }
+  /**
+   * 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)) {
-      logger3.info(
+      logger2.info(
         `Download for ${destPath} already in progress, waiting for it to complete...`
       );
       const existingDownload = this.activeDownloads.get(destPath);
       if (existingDownload) {
         return existingDownload;
       }
-      logger3.warn(
+      logger2.warn(
         `Download for ${destPath} was marked as in progress but not found in tracking map`
       );
     }
@@ -832,12 +552,20 @@ var DownloadManager = class _DownloadManager {
       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 {
-      logger3.info("Starting local model download...");
+      logger2.info("Starting local model download...");
       const modelDir = path.dirname(modelPath);
       if (!fs.existsSync(modelDir)) {
-        logger3.info("Creating model directory:", modelDir);
+        logger2.info("Creating model directory:", modelDir);
         fs.mkdirSync(modelDir, { recursive: true });
       }
       if (!fs.existsSync(modelPath)) {
@@ -863,20 +591,20 @@ var DownloadManager = class _DownloadManager {
         let downloadSuccess = false;
         for (const attempt of attempts) {
           try {
-            logger3.info("Attempting model download:", {
+            logger2.info("Attempting model download:", {
               description: attempt.description,
               url: attempt.url,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
             await this.downloadFile(attempt.url, modelPath);
-            logger3.success(
+            logger2.success(
               `Model download complete: ${modelSpec.name} using ${attempt.description}`
             );
             downloadSuccess = true;
             break;
           } catch (error) {
             lastError = error;
-            logger3.warn("Model download attempt failed:", {
+            logger2.warn("Model download attempt failed:", {
               description: attempt.description,
               error: error instanceof Error ? error.message : String(error),
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -888,10 +616,10 @@ var DownloadManager = class _DownloadManager {
         }
         return true;
       }
-      logger3.info("Model already exists at:", modelPath);
+      logger2.info("Model already exists at:", modelPath);
       return false;
     } catch (error) {
-      logger3.error("Model download failed:", {
+      logger2.error("Model download failed:", {
         error: error instanceof Error ? error.message : String(error),
         modelPath,
         model: modelSpec.name
@@ -899,22 +627,39 @@ var DownloadManager = class _DownloadManager {
       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 });
-      logger3.info(`Created directory: ${dirPath}`);
+      logger2.info(`Created directory: ${dirPath}`);
     }
   }
 };
 
 // src/utils/ollamaManager.ts
-import { logger as logger4, ModelTypes } from "@elizaos/core";
+import { ModelTypes, logger as logger3 } from "@elizaos/core";
 
 // ../../node_modules/node-fetch/src/index.js
 import http2 from "node:http";
@@ -964,7 +709,7 @@ var dist_default = dataUriToBuffer;
 
 // ../../node_modules/node-fetch/src/body.js
 import Stream, { PassThrough } from "node:stream";
-import { types, deprecate, promisify as promisify2 } from "node:util";
+import { types, deprecate, promisify } from "node:util";
 import { Buffer as Buffer2 } from "node:buffer";
 
 // ../../node_modules/node-fetch/src/errors/base.js
@@ -1021,7 +766,7 @@ var isSameProtocol = (destination, original) => {
 };
 
 // ../../node_modules/node-fetch/src/body.js
-var pipeline = promisify2(Stream.pipeline);
+var pipeline = promisify(Stream.pipeline);
 var INTERNALS = Symbol("Body internals");
 var Body = class {
   constructor(body, {
@@ -2203,20 +1948,32 @@ var OllamaManager = class _OllamaManager {
     small: process.env.SMALL_OLLAMA_MODEL || "deepseek-r1:1.5b",
     medium: process.env.MEDIUM_OLLAMA_MODEL || "deepseek-r1:7b"
   };
+  /**
+   * Private constructor for initializing OllamaManager.
+   */
   constructor() {
     this.serverUrl = process.env.OLLAMA_SERVER_URL || "http://localhost:11434";
-    logger4.info("OllamaManager initialized with configuration:", {
+    logger3.info("OllamaManager initialized with configuration:", {
       serverUrl: this.serverUrl,
       configuredModels: this.configuredModels,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
+  /**
+   * Returns an instance of the OllamaManager class.
+   * If an instance does not already exist, a new instance is created and returned.
+   * @returns {OllamaManager} The instance of the OllamaManager class.
+   */
   static getInstance() {
     if (!_OllamaManager.instance) {
       _OllamaManager.instance = new _OllamaManager();
     }
     return _OllamaManager.instance;
   }
+  /**
+   * Asynchronously checks the status of the server by attempting to fetch the "/api/tags" endpoint.
+   * @returns A Promise that resolves to a boolean indicating if the server is reachable and responding with a successful status.
+   */
   async checkServerStatus() {
     try {
       const response = await fetch2(`${this.serverUrl}/api/tags`);
@@ -2225,7 +1982,7 @@ var OllamaManager = class _OllamaManager {
       }
       return true;
     } catch (error) {
-      logger4.error("Ollama server check failed:", {
+      logger3.error("Ollama server check failed:", {
         error: error instanceof Error ? error.message : String(error),
         serverUrl: this.serverUrl,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2233,6 +1990,11 @@ var OllamaManager = class _OllamaManager {
       return false;
     }
   }
+  /**
+   * Fetches the available Ollama models from the specified server URL.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the available models are successfully fetched.
+   */
   async fetchAvailableModels() {
     try {
       const response = await fetch2(`${this.serverUrl}/api/tags`);
@@ -2241,13 +2003,13 @@ var OllamaManager = class _OllamaManager {
       }
       const data = await response.json();
       this.availableModels = data.models;
-      logger4.info("Ollama available models:", {
+      logger3.info("Ollama available models:", {
         count: this.availableModels.length,
         models: this.availableModels.map((m) => m.name),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch (error) {
-      logger4.error("Failed to fetch Ollama models:", {
+      logger3.error("Failed to fetch Ollama models:", {
         error: error instanceof Error ? error.message : String(error),
         serverUrl: this.serverUrl,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2255,6 +2017,12 @@ var OllamaManager = class _OllamaManager {
       throw error;
     }
   }
+  /**
+   * Asynchronously tests a model specified by the given modelId.
+   *
+   * @param {string} modelId - The ID of the model to be tested.
+   * @returns {Promise<boolean>} - A promise that resolves to true if the model test is successful, false otherwise.
+   */
   async testModel(modelId) {
     try {
       const testRequest = {
@@ -2266,7 +2034,7 @@ var OllamaManager = class _OllamaManager {
           num_predict: 100
         }
       };
-      logger4.info(`Testing model ${modelId}...`);
+      logger3.info(`Testing model ${modelId}...`);
       const response = await fetch2(`${this.serverUrl}/api/generate`, {
         method: "POST",
         headers: {
@@ -2281,14 +2049,14 @@ var OllamaManager = class _OllamaManager {
       if (!result.response) {
         throw new Error("No valid response content received");
       }
-      logger4.info(`Model ${modelId} test response:`, {
+      logger3.info(`Model ${modelId} test response:`, {
         content: result.response,
         model: result.model,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return true;
     } catch (error) {
-      logger4.error(`Model ${modelId} test failed:`, {
+      logger3.error(`Model ${modelId} test failed:`, {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2296,8 +2064,13 @@ var OllamaManager = class _OllamaManager {
       return false;
     }
   }
+  /**
+   * Asynchronously tests the configured text models to ensure they are working properly.
+   * Logs the test results for each model and outputs a warning if any models fail the test.
+   * @returns {Promise<void>} A Promise that resolves when all configured models have been tested.
+   */
   async testTextModels() {
-    logger4.info("Testing configured text models...");
+    logger3.info("Testing configured text models...");
     const results = await Promise.all([
       this.testModel(this.configuredModels.small),
       this.testModel(this.configuredModels.medium)
@@ -2307,22 +2080,28 @@ var OllamaManager = class _OllamaManager {
       const failedModels = [];
       if (!smallWorking) failedModels.push("small");
       if (!mediumWorking) failedModels.push("medium");
-      logger4.warn("Some models failed the test:", {
+      logger3.warn("Some models failed the test:", {
         failedModels,
         small: this.configuredModels.small,
         medium: this.configuredModels.medium
       });
     } else {
-      logger4.success("All configured models passed the test");
+      logger3.success("All configured models passed the test");
     }
   }
+  /**
+   * Asynchronously initializes the Ollama service by checking server status,
+   * fetching available models, and testing text models.
+   *
+   * @returns A Promise that resolves when initialization is complete
+   */
   async initialize() {
     try {
       if (this.initialized) {
-        logger4.info("Ollama already initialized, skipping initialization");
+        logger3.info("Ollama already initialized, skipping initialization");
         return;
       }
-      logger4.info("Starting Ollama initialization...");
+      logger3.info("Starting Ollama initialization...");
       const serverAvailable = await this.checkServerStatus();
       if (!serverAvailable) {
         throw new Error("Ollama server is not available");
@@ -2330,24 +2109,40 @@ var OllamaManager = class _OllamaManager {
       await this.fetchAvailableModels();
       await this.testTextModels();
       this.initialized = true;
-      logger4.success("Ollama initialization complete");
+      logger3.success("Ollama initialization complete");
     } catch (error) {
-      logger4.error("Ollama initialization failed:", {
+      logger3.error("Ollama initialization failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0
       });
       throw error;
     }
   }
+  /**
+   * Retrieves the available Ollama models.
+   *
+   * @returns {OllamaModel[]} An array of OllamaModel objects representing the available models.
+   */
   getAvailableModels() {
     return this.availableModels;
   }
+  /**
+   * Check if the object is initialized.
+   * @returns {boolean} True if the object is initialized, false otherwise.
+   */
   isInitialized() {
     return this.initialized;
   }
+  /**
+   * Generates text using the Ollama AI model.
+   *
+   * @param {GenerateTextParams} params - The parameters for generating text.
+   * @param {boolean} [isInitialized=false] - Flag indicating if Ollama is already initialized.
+   * @returns {Promise<string>} - A promise that resolves with the generated text.
+   */
   async generateText(params, isInitialized = false) {
     try {
-      logger4.info("Ollama generateText entry:", {
+      logger3.info("Ollama generateText entry:", {
         isInitialized,
         currentInitState: this.initialized,
         managerInitState: this.isInitialized(),
@@ -2360,7 +2155,7 @@ var OllamaManager = class _OllamaManager {
           "Ollama not initialized. Please initialize before generating text."
         );
       }
-      logger4.info("Ollama preparing request:", {
+      logger3.info("Ollama preparing request:", {
         model: params.modelType === ModelTypes.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
         contextLength: params.prompt.length,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2393,24 +2188,24 @@ var OllamaManager = class _OllamaManager {
         throw new Error("No valid response content received from Ollama");
       }
       let responseText = result.response;
-      logger4.info("Raw response structure:", {
+      logger3.info("Raw response structure:", {
         responseLength: responseText.length,
         hasAction: responseText.includes("action"),
         hasThinkTag: responseText.includes("<think>")
       });
       if (responseText.includes("<think>")) {
-        logger4.info("Cleaning think tags from response");
+        logger3.info("Cleaning think tags from response");
         responseText = responseText.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-        logger4.info("Think tags removed from response");
+        logger3.info("Think tags removed from response");
       }
-      logger4.info("Ollama request completed successfully:", {
+      logger3.info("Ollama request completed successfully:", {
         responseLength: responseText.length,
         hasThinkTags: responseText.includes("<think>"),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return responseText;
     } catch (error) {
-      logger4.error("Ollama text generation error:", {
+      logger3.error("Ollama text generation error:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         phase: "text generation",
@@ -2421,8 +2216,341 @@ var OllamaManager = class _OllamaManager {
   }
 };
 
+// src/utils/platform.ts
+import { exec } from "node:child_process";
+import os from "node:os";
+import { promisify as promisify2 } from "node:util";
+import { logger as logger4 } from "@elizaos/core";
+var execAsync = promisify2(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 {
+      logger4.info("Initializing platform detection...");
+      this.capabilities = await this.detectSystemCapabilities();
+    } catch (error) {
+      logger4.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) {
+      logger4.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) {
+      logger4.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) {
+      logger4.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) {
+        logger4.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/studiolmManager.ts
-import { logger as logger5, ModelTypes as ModelTypes2 } from "@elizaos/core";
+import { ModelTypes as ModelTypes2, logger as logger5 } from "@elizaos/core";
 var StudioLMManager = class _StudioLMManager {
   static instance = null;
   serverUrl;
@@ -2432,6 +2560,11 @@ var StudioLMManager = class _StudioLMManager {
     small: process.env.STUDIOLM_SMALL_MODEL || "lmstudio-community/deepseek-r1-distill-qwen-1.5b",
     medium: process.env.STUDIOLM_MEDIUM_MODEL || "deepseek-r1-distill-qwen-7b"
   };
+  /**
+   * Private constructor for StudioLMManager.
+   * Initializes with default serverUrl if not provided in environment variables.
+   * Logs initialization information including serverUrl, configuredModels, and timestamp.
+   */
   constructor() {
     this.serverUrl = process.env.STUDIOLM_SERVER_URL || "http://localhost:1234";
     logger5.info("StudioLMManager initialized with configuration:", {
@@ -2440,12 +2573,20 @@ var StudioLMManager = class _StudioLMManager {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
+  /**
+   * Returns an instance of StudioLMManager. If an instance already exists, it returns the existing instance.
+   * @returns {StudioLMManager} The instance of StudioLMManager
+   */
   static getInstance() {
     if (!_StudioLMManager.instance) {
       _StudioLMManager.instance = new _StudioLMManager();
     }
     return _StudioLMManager.instance;
   }
+  /**
+   * Check the status of the server by sending a request to the /v1/models endpoint.
+   * @returns {Promise<boolean>} A Promise that resolves to true if the server responds with success status, false otherwise.
+   */
   async checkServerStatus() {
     try {
       const response = await fetch2(`${this.serverUrl}/v1/models`);
@@ -2462,6 +2603,11 @@ var StudioLMManager = class _StudioLMManager {
       return false;
     }
   }
+  /**
+   * Fetches the available models from the server and stores them in the 'availableModels' property.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the models are fetched successfully or rejects with an error.
+   */
   async fetchAvailableModels() {
     try {
       const response = await fetch2(`${this.serverUrl}/v1/models`);
@@ -2484,6 +2630,11 @@ var StudioLMManager = class _StudioLMManager {
       throw error;
     }
   }
+  /**
+   * Asynchronously tests the specified model with a chat completion request.
+   * @param {string} modelId - The ID of the model to test.
+   * @returns {Promise<boolean>} - A promise that resolves to true if the model test was successful, false otherwise.
+   */
   async testModel(modelId) {
     try {
       const testRequest = {
@@ -2529,6 +2680,11 @@ var StudioLMManager = class _StudioLMManager {
       return false;
     }
   }
+  /**
+   * Tests the configured text models to ensure they are working properly.
+   * Logs the results of the test and any failed models.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   */
   async testTextModels() {
     logger5.info("Testing configured text models...");
     const results = await Promise.all([
@@ -2549,6 +2705,12 @@ var StudioLMManager = class _StudioLMManager {
       logger5.success("All configured models passed the test");
     }
   }
+  /**
+   * Initializes StudioLM by checking server status, fetching available models,
+   * and testing text models.
+   *
+   * @returns {Promise<void>} A Promise that resolves when initialization is complete
+   */
   async initialize() {
     try {
       if (this.initialized) {
@@ -2572,12 +2734,29 @@ var StudioLMManager = class _StudioLMManager {
       throw error;
     }
   }
+  /**
+   * Retrieves the available models in the studio.
+   *
+   * @returns {StudioLMModel[]} An array of StudioLMModel objects representing the available models.
+   */
   getAvailableModels() {
     return this.availableModels;
   }
+  /**
+   * Check if the object is initialized.
+   *
+   * @returns {boolean} Returns true if the object is initialized, otherwise false.
+   */
   isInitialized() {
     return this.initialized;
   }
+  /**
+   * Asynchronously generates text using StudioLM based on provided parameters.
+   *
+   * @param {GenerateTextParams} params - The parameters for generating text.
+   * @param {boolean} [isInitialized=false] - Flag to indicate if the model is already initialized.
+   * @returns {Promise<string>} The generated text as a Promise.
+   */
   async generateText(params, isInitialized = false) {
     try {
       logger5.info("StudioLM generateText entry:", {
@@ -2605,56 +2784,245 @@ var StudioLMManager = class _StudioLMManager {
         messageCount: messages.length,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      logger5.info("Incoming context structure:", {
-        contextLength: params.prompt.length,
-        hasAction: params.prompt.includes("action"),
-        runtime: !!params.runtime,
-        stopSequences: params.stopSequences
+      logger5.info("Incoming context structure:", {
+        contextLength: params.prompt.length,
+        hasAction: params.prompt.includes("action"),
+        runtime: !!params.runtime,
+        stopSequences: params.stopSequences
+      });
+      const request = {
+        model: params.modelType === ModelTypes2.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
+        messages,
+        temperature: 0.7,
+        max_tokens: 8192,
+        stream: false
+      };
+      const response = await fetch2(`${this.serverUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(request)
+      });
+      if (!response.ok) {
+        throw new Error(`StudioLM request failed: ${response.status}`);
+      }
+      const result = await response.json();
+      if (!result.choices?.[0]?.message?.content) {
+        throw new Error("No valid response content received from StudioLM");
+      }
+      let responseText = result.choices[0].message.content;
+      logger5.info("Raw response structure:", {
+        responseLength: responseText.length,
+        hasAction: responseText.includes("action"),
+        hasThinkTag: responseText.includes("<think>")
+      });
+      if (responseText.includes("<think>")) {
+        logger5.info("Cleaning think tags from response");
+        responseText = responseText.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
+        logger5.info("Think tags removed from response");
+      }
+      logger5.info("StudioLM request completed successfully:", {
+        responseLength: responseText.length,
+        hasThinkTags: responseText.includes("<think>"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return responseText;
+    } catch (error) {
+      logger5.error("StudioLM text generation error:", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        phase: "text generation",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      throw error;
+    }
+  }
+};
+
+// src/utils/tokenizerManager.ts
+import { logger as logger6 } 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}`;
+      logger6.info("Loading tokenizer:", {
+        key: tokenizerKey,
+        name: modelConfig.tokenizer.name,
+        type: modelConfig.tokenizer.type,
+        modelsDir: this.modelsDir,
+        cacheDir: this.cacheDir
+      });
+      if (this.tokenizers.has(tokenizerKey)) {
+        logger6.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 fs6 = await import("node:fs");
+      if (!fs6.existsSync(this.modelsDir)) {
+        logger6.warn(
+          "Models directory does not exist, creating it:",
+          this.modelsDir
+        );
+        fs6.mkdirSync(this.modelsDir, { recursive: true });
+      }
+      logger6.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);
+        logger6.success("Tokenizer loaded successfully:", { key: tokenizerKey });
+        return tokenizer;
+      } catch (tokenizeError) {
+        logger6.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
+        });
+        logger6.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);
+        logger6.success("Tokenizer loaded successfully on retry:", {
+          key: tokenizerKey
+        });
+        return tokenizer;
+      }
+    } catch (error) {
+      logger6.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 {
+      logger6.info("Encoding text with tokenizer:", {
+        length: text.length,
+        tokenizer: modelConfig.tokenizer.name
+      });
+      const tokenizer = await this.loadTokenizer(modelConfig);
+      logger6.info("Tokenizer loaded, encoding text...");
+      const encoded = await tokenizer.encode(text, {
+        add_special_tokens: true,
+        return_token_type_ids: false
       });
-      const request = {
-        model: params.modelType === ModelTypes2.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
-        messages,
-        temperature: 0.7,
-        max_tokens: 8192,
-        stream: false
-      };
-      const response = await fetch2(`${this.serverUrl}/v1/chat/completions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(request)
+      logger6.info("Text encoded successfully:", {
+        tokenCount: encoded.length,
+        tokenizer: modelConfig.tokenizer.name
       });
-      if (!response.ok) {
-        throw new Error(`StudioLM request failed: ${response.status}`);
-      }
-      const result = await response.json();
-      if (!result.choices?.[0]?.message?.content) {
-        throw new Error("No valid response content received from StudioLM");
-      }
-      let responseText = result.choices[0].message.content;
-      logger5.info("Raw response structure:", {
-        responseLength: responseText.length,
-        hasAction: responseText.includes("action"),
-        hasThinkTag: responseText.includes("<think>")
+      return encoded;
+    } catch (error) {
+      logger6.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
       });
-      if (responseText.includes("<think>")) {
-        logger5.info("Cleaning think tags from response");
-        responseText = responseText.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-        logger5.info("Think tags removed from response");
-      }
-      logger5.info("StudioLM request completed successfully:", {
-        responseLength: responseText.length,
-        hasThinkTags: responseText.includes("<think>"),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      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 {
+      logger6.info("Decoding tokens with tokenizer:", {
+        count: tokens.length,
+        tokenizer: modelConfig.tokenizer.name
       });
-      return responseText;
+      const tokenizer = await this.loadTokenizer(modelConfig);
+      logger6.info("Tokenizer loaded, decoding tokens...");
+      const decoded = await tokenizer.decode(tokens, {
+        skip_special_tokens: true,
+        clean_up_tokenization_spaces: true
+      });
+      logger6.info("Tokens decoded successfully:", {
+        textLength: decoded.length,
+        tokenizer: modelConfig.tokenizer.name
+      });
+      return decoded;
     } catch (error) {
-      logger5.error("StudioLM text generation error:", {
+      logger6.error("Token decoding failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
-        phase: "text generation",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        tokenCount: tokens.length,
+        tokenizer: modelConfig.tokenizer.name,
+        modelsDir: this.modelsDir
       });
       throw error;
     }
@@ -2662,12 +3030,12 @@ var StudioLMManager = class _StudioLMManager {
 };
 
 // src/utils/transcribeManager.ts
-import { logger as logger6 } from "@elizaos/core";
-import { nodewhisper } from "nodejs-whisper";
+import { exec as exec2 } from "node:child_process";
 import fs2 from "node:fs";
 import path2 from "node:path";
 import { promisify as promisify3 } from "node:util";
-import { exec as exec2 } from "node:child_process";
+import { logger as logger7 } from "@elizaos/core";
+import { nodewhisper } from "nodejs-whisper";
 var execAsync2 = promisify3(exec2);
 var TranscribeManager = class _TranscribeManager {
   static instance = null;
@@ -2676,21 +3044,30 @@ var TranscribeManager = class _TranscribeManager {
   ffmpegVersion = null;
   ffmpegPath = null;
   ffmpegInitialized = false;
+  /**
+   * Constructor for TranscribeManager class.
+   *
+   * @param {string} cacheDir - The directory path for storing cached files.
+   */
   constructor(cacheDir) {
     this.cacheDir = path2.join(cacheDir, "whisper");
-    logger6.info("Initializing TranscribeManager", {
+    logger7.info("Initializing TranscribeManager", {
       cacheDir: this.cacheDir,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
     this.ensureCacheDirectory();
   }
+  /**
+   * Ensures that FFmpeg is initialized and available for use.
+   * @returns {Promise<boolean>} A promise that resolves to a boolean value indicating if FFmpeg is available.
+   */
   async ensureFFmpeg() {
     if (!this.ffmpegInitialized) {
       try {
         await this.initializeFFmpeg();
         this.ffmpegInitialized = true;
       } catch (error) {
-        logger6.error("FFmpeg initialization failed:", {
+        logger7.error("FFmpeg initialization failed:", {
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : void 0,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2700,31 +3077,57 @@ var TranscribeManager = class _TranscribeManager {
     }
     return this.ffmpegAvailable;
   }
+  /**
+   * Checks if FFmpeg is available.
+   * @returns {boolean} True if FFmpeg is available, false otherwise.
+   */
   isFFmpegAvailable() {
     return this.ffmpegAvailable;
   }
+  /**
+   * Asynchronously retrieves the FFmpeg version if it hasn't been fetched yet.
+   * If the FFmpeg version has already been fetched, it will return the stored version.
+   * @returns A Promise that resolves with the FFmpeg version as a string, or null if the version is not available.
+   */
   async getFFmpegVersion() {
     if (!this.ffmpegVersion) {
       await this.fetchFFmpegVersion();
     }
     return this.ffmpegVersion;
   }
+  /**
+   * Fetches the FFmpeg version by executing the command "ffmpeg -version".
+   * Updates the class property ffmpegVersion with the retrieved version.
+   * Logs the FFmpeg version information or error message.
+   * @returns {Promise<void>} A Promise that resolves once the FFmpeg version is fetched and logged.
+   */
   async fetchFFmpegVersion() {
     try {
       const { stdout } = await execAsync2("ffmpeg -version");
       this.ffmpegVersion = stdout.split("\n")[0];
-      logger6.info("FFmpeg version:", {
+      logger7.info("FFmpeg version:", {
         version: this.ffmpegVersion,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch (error) {
       this.ffmpegVersion = null;
-      logger6.error("Failed to get FFmpeg version:", {
+      logger7.error("Failed to get FFmpeg version:", {
         error: error instanceof Error ? error.message : String(error),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
   }
+  /**
+   * Initializes FFmpeg by performing the following steps:
+   * 1. Checks for FFmpeg availability in PATH
+   * 2. Retrieves FFmpeg version information
+   * 3. Verifies FFmpeg capabilities
+   *
+   * If FFmpeg is available, logs a success message with version, path, and timestamp.
+   * If FFmpeg is not available, logs installation instructions.
+   *
+   * @returns A Promise that resolves once FFmpeg has been successfully initialized
+   */
   async initializeFFmpeg() {
     try {
       await this.checkFFmpegAvailability();
@@ -2736,7 +3139,7 @@ var TranscribeManager = class _TranscribeManager {
       }
     } catch (error) {
       this.ffmpegAvailable = false;
-      logger6.error("FFmpeg initialization failed:", {
+      logger7.error("FFmpeg initialization failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2744,6 +3147,13 @@ var TranscribeManager = class _TranscribeManager {
       this.logFFmpegInstallInstructions();
     }
   }
+  /**
+   * Asynchronously checks for the availability of FFmpeg in the system by executing a command to find the FFmpeg location.
+   * Updates the class properties `ffmpegPath` and `ffmpegAvailable` accordingly.
+   * Logs relevant information such as FFmpeg location and potential errors using the logger.
+   *
+   * @returns A Promise that resolves with no value upon completion.
+   */
   async checkFFmpegAvailability() {
     try {
       const { stdout, stderr } = await execAsync2(
@@ -2751,7 +3161,7 @@ var TranscribeManager = class _TranscribeManager {
       );
       this.ffmpegPath = stdout.trim();
       this.ffmpegAvailable = true;
-      logger6.info("FFmpeg found at:", {
+      logger7.info("FFmpeg found at:", {
         path: this.ffmpegPath,
         stderr: stderr ? stderr.trim() : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2759,13 +3169,18 @@ var TranscribeManager = class _TranscribeManager {
     } catch (error) {
       this.ffmpegAvailable = false;
       this.ffmpegPath = null;
-      logger6.error("FFmpeg not found in PATH:", {
+      logger7.error("FFmpeg not found in PATH:", {
         error: error instanceof Error ? error.message : String(error),
         stderr: error instanceof Error && "stderr" in error ? error.stderr : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
   }
+  /**
+   * Verifies the FFmpeg capabilities by checking if FFmpeg supports the required codecs and formats.
+   *
+   * @returns {Promise<void>} A Promise that resolves if FFmpeg has the required codecs, otherwise rejects with an error message.
+   */
   async verifyFFmpegCapabilities() {
     try {
       const { stdout } = await execAsync2("ffmpeg -codecs");
@@ -2776,15 +3191,18 @@ var TranscribeManager = class _TranscribeManager {
         );
       }
     } catch (error) {
-      logger6.error("FFmpeg capabilities verification failed:", {
+      logger7.error("FFmpeg capabilities verification failed:", {
         error: error instanceof Error ? error.message : String(error),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       throw error;
     }
   }
+  /**
+   * Logs instructions on how to install FFmpeg if it is not properly installed.
+   */
   logFFmpegInstallInstructions() {
-    logger6.warn(
+    logger7.warn(
       "FFmpeg is required but not properly installed. Please install FFmpeg:",
       {
         instructions: {
@@ -2799,17 +3217,36 @@ var TranscribeManager = class _TranscribeManager {
       }
     );
   }
+  /**
+   * Gets the singleton instance of TranscribeManager, creates a new instance if it doesn't exist.
+   *
+   * @param {string} cacheDir - The directory path for caching transcriptions.
+   * @returns {TranscribeManager} The singleton instance of TranscribeManager.
+   */
   static getInstance(cacheDir) {
     if (!_TranscribeManager.instance) {
       _TranscribeManager.instance = new _TranscribeManager(cacheDir);
     }
     return _TranscribeManager.instance;
   }
+  /**
+   * Ensures that the cache directory exists. If it doesn't exist,
+   * creates the directory using fs.mkdirSync with recursive set to true.
+   * @returns {void}
+   */
   ensureCacheDirectory() {
     if (!fs2.existsSync(this.cacheDir)) {
       fs2.mkdirSync(this.cacheDir, { recursive: true });
     }
   }
+  /**
+   * Converts an audio file to WAV format using FFmpeg.
+   *
+   * @param {string} inputPath - The input path of the audio file to convert.
+   * @param {string} outputPath - The output path where the converted WAV file will be saved.
+   * @returns {Promise<void>} A Promise that resolves when the conversion is completed.
+   * @throws {Error} If FFmpeg is not installed or not properly configured, or if the audio conversion fails.
+   */
   async convertToWav(inputPath, outputPath) {
     if (!this.ffmpegAvailable) {
       throw new Error(
@@ -2821,7 +3258,7 @@ var TranscribeManager = class _TranscribeManager {
         `ffmpeg -y -loglevel error -i "${inputPath}" -acodec pcm_s16le -ar 16000 -ac 1 "${outputPath}"`
       );
       if (stderr) {
-        logger6.warn("FFmpeg conversion error:", {
+        logger7.warn("FFmpeg conversion error:", {
           stderr,
           inputPath,
           outputPath,
@@ -2832,7 +3269,7 @@ var TranscribeManager = class _TranscribeManager {
         throw new Error("WAV file was not created successfully");
       }
     } catch (error) {
-      logger6.error("Audio conversion failed:", {
+      logger7.error("Audio conversion failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         command: `ffmpeg -y -loglevel error -i "${inputPath}" -acodec pcm_s16le -ar 16000 -ac 1 "${outputPath}"`,
@@ -2846,6 +3283,14 @@ var TranscribeManager = class _TranscribeManager {
       );
     }
   }
+  /**
+   * Asynchronously preprocesses the audio by converting the provided audio buffer into a WAV file.
+   * If FFmpeg is not installed, an error is thrown.
+   *
+   * @param {Buffer} audioBuffer The audio buffer to preprocess
+   * @returns {Promise<string>} The path to the preprocessed WAV file
+   * @throws {Error} If FFmpeg is not installed or if audio preprocessing fails
+   */
   async preprocessAudio(audioBuffer) {
     if (!this.ffmpegAvailable) {
       throw new Error(
@@ -2865,7 +3310,7 @@ var TranscribeManager = class _TranscribeManager {
       }
       return tempWavFile;
     } catch (error) {
-      logger6.error("Audio preprocessing failed:", {
+      logger7.error("Audio preprocessing failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         ffmpegAvailable: this.ffmpegAvailable,
@@ -2876,6 +3321,13 @@ var TranscribeManager = class _TranscribeManager {
       );
     }
   }
+  /**
+   * Transcribes the audio buffer to text using whisper.
+   *
+   * @param {Buffer} audioBuffer The audio buffer to transcribe.
+   * @returns {Promise<TranscriptionResult>} A promise that resolves with the transcription result.
+   * @throws {Error} If FFmpeg is not installed or properly configured.
+   */
   async transcribe(audioBuffer) {
     await this.ensureFFmpeg();
     if (!this.ffmpegAvailable) {
@@ -2885,7 +3337,7 @@ var TranscribeManager = class _TranscribeManager {
     }
     try {
       const wavFile = await this.preprocessAudio(audioBuffer);
-      logger6.info("Starting transcription with whisper...");
+      logger7.info("Starting transcription with whisper...");
       const originalStdoutWrite = process.stdout.write;
       const originalStderrWrite = process.stderr.write;
       const noopWrite = () => true;
@@ -2908,19 +3360,19 @@ var TranscribeManager = class _TranscribeManager {
       }
       if (fs2.existsSync(wavFile)) {
         fs2.unlinkSync(wavFile);
-        logger6.info("Temporary WAV file cleaned up");
+        logger7.info("Temporary WAV file cleaned up");
       }
       const cleanText = output.split("\n").map((line) => {
         const textMatch = line.match(/](.+)$/);
         return textMatch ? textMatch[1].trim() : line.trim();
       }).filter((line) => line).join(" ");
-      logger6.success("Transcription complete:", {
+      logger7.success("Transcription complete:", {
         textLength: cleanText.length,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return { text: cleanText };
     } catch (error) {
-      logger6.error("Transcription failed:", {
+      logger7.error("Transcription failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         ffmpegAvailable: this.ffmpegAvailable
@@ -2931,13 +3383,13 @@ var TranscribeManager = class _TranscribeManager {
 };
 
 // src/utils/ttsManager.ts
-import { logger as logger7 } from "@elizaos/core";
 import fs3 from "node:fs";
 import path3 from "node:path";
+import { Readable } from "node:stream";
+import { logger as logger8 } from "@elizaos/core";
 import {
   getLlama
 } from "node-llama-cpp";
-import { Readable } from "node:stream";
 
 // src/utils/audioUtils.ts
 import { PassThrough as PassThrough3 } from "node:stream";
@@ -2990,6 +3442,11 @@ var TTSManager = class _TTSManager {
   initialized = false;
   downloadManager;
   modelsDir;
+  /**
+   * Creates a new instance of TTSManager with the provided cache directory.
+   *
+   * @param {string} cacheDir - The directory where cached data will be stored.
+   */
   constructor(cacheDir) {
     this.cacheDir = path3.join(cacheDir, "tts");
     this.modelsDir = process.env.LLAMALOCAL_PATH?.trim() ? path3.resolve(process.env.LLAMALOCAL_PATH.trim()) : path3.join(process.cwd(), "models");
@@ -2998,26 +3455,44 @@ var TTSManager = class _TTSManager {
       this.modelsDir
     );
     this.ensureCacheDirectory();
-    logger7.info("TTSManager initialized");
+    logger8.info("TTSManager initialized");
   }
+  /**
+   * Returns an instance of TTSManager, creating a new one if none exist.
+   *
+   * @param {string} cacheDir - The directory path to store cached audio files.
+   * @returns {TTSManager} An instance of TTSManager.
+   */
   static getInstance(cacheDir) {
     if (!_TTSManager.instance) {
       _TTSManager.instance = new _TTSManager(cacheDir);
     }
     return _TTSManager.instance;
   }
+  /**
+   * Ensures that the cache directory exists. If it does not exist, the directory will be created.
+   */
   ensureCacheDirectory() {
     if (!fs3.existsSync(this.cacheDir)) {
       fs3.mkdirSync(this.cacheDir, { recursive: true });
-      logger7.info("Created TTS cache directory:", this.cacheDir);
+      logger8.info("Created TTS cache directory:", this.cacheDir);
     }
   }
+  /**
+   * Asynchronously initializes the TTS module with GGUF backend.
+   * If already initialized or missing necessary components (model and context), it returns early.
+   * Handles model download using different URL patterns as fallback if model not found locally.
+   * Initializes the TTS model, creates context, and sets the sequence for TTS generation.
+   * Logs detailed steps and final output of initialization.
+   *
+   * @returns {Promise<void>} A promise that resolves once the TTS module is fully initialized.
+   */
   async initialize() {
     try {
       if (this.initialized && this.model && this.ctx) {
         return;
       }
-      logger7.info("Initializing TTS with GGUF backend...");
+      logger8.info("Initializing TTS with GGUF backend...");
       const modelSpec = MODEL_SPECS.tts.base;
       const modelPath = path3.join(this.modelsDir, modelSpec.name);
       if (!fs3.existsSync(modelPath)) {
@@ -3041,7 +3516,7 @@ var TTSManager = class _TTSManager {
         let lastError = null;
         for (const attempt of attempts) {
           try {
-            logger7.info("Attempting TTS model download:", {
+            logger8.info("Attempting TTS model download:", {
               description: attempt.description,
               repo: attempt.spec.repo,
               name: attempt.spec.name,
@@ -3050,18 +3525,18 @@ var TTSManager = class _TTSManager {
             });
             const barLength = 30;
             const emptyBar = "\u25B1".repeat(barLength);
-            logger7.info(`Downloading TTS model: ${emptyBar} 0%`);
+            logger8.info(`Downloading TTS model: ${emptyBar} 0%`);
             await this.downloadManager.downloadFromUrl(attempt.url, modelPath);
             const completedBar = "\u25B0".repeat(barLength);
-            logger7.info(`Downloading TTS model: ${completedBar} 100%`);
-            logger7.success(
+            logger8.info(`Downloading TTS model: ${completedBar} 100%`);
+            logger8.success(
               "TTS model download successful with:",
               attempt.description
             );
             break;
           } catch (error) {
             lastError = error;
-            logger7.warn("TTS model download attempt failed:", {
+            logger8.warn("TTS model download attempt failed:", {
               description: attempt.description,
               error: error instanceof Error ? error.message : String(error),
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -3072,7 +3547,7 @@ var TTSManager = class _TTSManager {
           throw lastError || new Error("All download attempts failed");
         }
       }
-      logger7.info("Loading TTS model...");
+      logger8.info("Loading TTS model...");
       const llama = await getLlama();
       this.model = await llama.loadModel({
         modelPath,
@@ -3083,14 +3558,14 @@ var TTSManager = class _TTSManager {
         contextSize: modelSpec.contextSize
       });
       this.sequence = this.ctx.getSequence();
-      logger7.success("TTS initialization complete", {
+      logger8.success("TTS initialization complete", {
         modelPath,
         contextSize: modelSpec.contextSize,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       this.initialized = true;
     } catch (error) {
-      logger7.error("TTS initialization failed:", {
+      logger8.error("TTS initialization failed:", {
         error: error instanceof Error ? error.message : String(error),
         model: MODEL_SPECS.tts.base.name,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -3098,20 +3573,26 @@ var TTSManager = class _TTSManager {
       throw error;
     }
   }
+  /**
+   * Asynchronously generates speech from a given text using the initialized TTS model.
+   * @param {string} text - The text to generate speech from.
+   * @returns {Promise<Readable>} A promise that resolves to a Readable stream containing the generated audio data.
+   * @throws {Error} If the TTS model is not initialized or if no audio tokens are generated.
+   */
   async generateSpeech(text) {
     try {
       await this.initialize();
       if (!this.model || !this.ctx || !this.sequence) {
         throw new Error("TTS model not initialized");
       }
-      logger7.info("Starting speech generation for text:", { text });
+      logger8.info("Starting speech generation for text:", { text });
       const prompt = `[SPEAKER=female_1][LANGUAGE=en]${text}`;
-      logger7.info("Formatted prompt:", { prompt });
-      logger7.info("Tokenizing input...");
+      logger8.info("Formatted prompt:", { prompt });
+      logger8.info("Tokenizing input...");
       const inputTokens = this.model.tokenize(prompt);
-      logger7.info("Input tokenized:", { tokenCount: inputTokens.length });
+      logger8.info("Input tokenized:", { tokenCount: inputTokens.length });
       const maxTokens = inputTokens.length * 2;
-      logger7.info("Starting token generation with optimized limit:", {
+      logger8.info("Starting token generation with optimized limit:", {
         maxTokens
       });
       const responseTokens = [];
@@ -3127,28 +3608,28 @@ var TTSManager = class _TTSManager {
             responseTokens.length / maxTokens * barLength
           );
           const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-          logger7.info(
+          logger8.info(
             `Token generation: ${progressBar} ${percent}% (${responseTokens.length}/${maxTokens})`
           );
           if (responseTokens.length >= maxTokens) {
-            logger7.info("Token generation complete");
+            logger8.info("Token generation complete");
             break;
           }
         }
       } catch (error) {
-        logger7.error("Token generation error:", error);
+        logger8.error("Token generation error:", error);
         throw error;
       }
       if (responseTokens.length === 0) {
         throw new Error("No audio tokens generated");
       }
-      logger7.info("Converting tokens to audio data...");
+      logger8.info("Converting tokens to audio data...");
       const audioData = this.processAudioResponse({
         tokens: responseTokens.map(
           (t) => Number.parseInt(this.model.detokenize([t]), 10)
         )
       });
-      logger7.info("Audio data generated:", {
+      logger8.info("Audio data generated:", {
         byteLength: audioData.length,
         sampleRate: MODEL_SPECS.tts.base.sampleRate
       });
@@ -3159,16 +3640,27 @@ var TTSManager = class _TTSManager {
         1,
         16
       );
-      logger7.success("Speech generation complete");
+      logger8.success("Speech generation complete");
       return audioStream;
     } catch (error) {
-      logger7.error("Speech generation failed:", {
+      logger8.error("Speech generation failed:", {
         error: error instanceof Error ? error.message : String(error),
         text
       });
       throw error;
     }
   }
+  /**
+   * Processes the audio response from the TTS service by converting
+   * the data to 16-bit PCM format.
+   * If the response contains direct audio data, it converts Float32Array
+   * to 16-bit PCM. If the response only contains tokens, it converts
+   * them to PCM data. The actual conversion process may vary depending
+   * on the model used.
+   *
+   * @param {TTSResponse} response - The response object from the TTS service
+   * @returns {Buffer} The processed audio data in 16-bit PCM format
+   */
   processAudioResponse(response) {
     if (response.audio) {
       const pcmData2 = new Int16Array(response.audio.length);
@@ -3188,19 +3680,19 @@ var TTSManager = class _TTSManager {
 };
 
 // src/utils/visionManager.ts
-import { logger as logger8 } from "@elizaos/core";
+import { existsSync } from "node:fs";
+import fs4 from "node:fs";
+import os2 from "node:os";
+import path4 from "node:path";
+import process2 from "node:process";
+import { logger as logger9 } from "@elizaos/core";
 import {
   AutoProcessor,
   AutoTokenizer as AutoTokenizer2,
-  env,
   Florence2ForConditionalGeneration,
-  RawImage
+  RawImage,
+  env
 } from "@huggingface/transformers";
-import { existsSync } from "node:fs";
-import path4 from "node:path";
-import process2 from "node:process";
-import fs4 from "node:fs";
-import os2 from "node:os";
 var VisionManager = class _VisionManager {
   static instance = null;
   model = null;
@@ -3220,6 +3712,11 @@ var VisionManager = class _VisionManager {
     { name: "decoder_model_merged", type: "decoder" },
     { name: "encoder_model", type: "encoder" }
   ];
+  /**
+   * Constructor for VisionManager class.
+   *
+   * @param {string} cacheDir - The directory path for caching vision models.
+   */
   constructor(cacheDir) {
     this.modelsDir = path4.join(path4.dirname(cacheDir), "models", "vision");
     this.cacheDir = cacheDir;
@@ -3229,8 +3726,12 @@ var VisionManager = class _VisionManager {
       this.modelsDir
     );
     this.platformConfig = this.getPlatformConfig();
-    logger8.info("VisionManager initialized");
+    logger9.info("VisionManager initialized");
   }
+  /**
+   * Retrieves the platform configuration based on the operating system and architecture.
+   * @returns {PlatformConfig} The platform configuration object with device, dtype, and useOnnx properties.
+   */
   getPlatformConfig() {
     const platform = os2.platform();
     const arch = os2.arch();
@@ -3255,25 +3756,42 @@ var VisionManager = class _VisionManager {
         };
       }
     }
-    logger8.info("Platform configuration detected:", {
+    logger9.info("Platform configuration detected:", {
       platform,
       arch,
       config
     });
     return config;
   }
+  /**
+   * Ensures that the models directory exists. If it does not exist, it creates the directory.
+   */
   ensureModelsDirExists() {
     if (!existsSync(this.modelsDir)) {
-      logger8.info(`Creating models directory at: ${this.modelsDir}`);
+      logger9.info(`Creating models directory at: ${this.modelsDir}`);
       fs4.mkdirSync(this.modelsDir, { recursive: true });
     }
   }
+  /**
+   * Returns the singleton instance of VisionManager.
+   * If an instance does not already exist, a new instance is created with the specified cache directory.
+   *
+   * @param {string} cacheDir - The directory where cache files will be stored.
+   *
+   * @returns {VisionManager} The singleton instance of VisionManager.
+   */
   static getInstance(cacheDir) {
     if (!_VisionManager.instance) {
       _VisionManager.instance = new _VisionManager(cacheDir);
     }
     return _VisionManager.instance;
   }
+  /**
+   * Check if the cache exists for the specified model or tokenizer or processor.
+   * @param {string} modelId - The ID of the model.
+   * @param {"model" | "tokenizer" | "processor"} type - The type of the cache ("model", "tokenizer", or "processor").
+   * @returns {boolean} - Returns true if cache exists, otherwise returns false.
+   */
   checkCacheExists(modelId, type) {
     const modelPath = path4.join(
       this.modelsDir,
@@ -3281,11 +3799,16 @@ var VisionManager = class _VisionManager {
       type
     );
     if (existsSync(modelPath)) {
-      logger8.info(`${type} found at: ${modelPath}`);
+      logger9.info(`${type} found at: ${modelPath}`);
       return true;
     }
     return false;
   }
+  /**
+   * Configures the model components based on the platform and architecture.
+   * Sets the default data type (dtype) for components based on platform capabilities.
+   * Updates all component dtypes to match the default dtype.
+   */
   configureModelComponents() {
     const platform = os2.platform();
     const arch = os2.arch();
@@ -3299,13 +3822,18 @@ var VisionManager = class _VisionManager {
       ...component,
       dtype: defaultDtype
     }));
-    logger8.info("Model components configured with dtype:", {
+    logger9.info("Model components configured with dtype:", {
       platform,
       arch,
       defaultDtype,
       components: this.modelComponents.map((c) => `${c.name}: ${c.dtype}`)
     });
   }
+  /**
+   * Get the model configuration based on the input component name.
+   * @param {string} componentName - The name of the component to retrieve the configuration for.
+   * @returns {object} The model configuration object containing device, dtype, and cache_dir.
+   */
   getModelConfig(componentName) {
     const component = this.modelComponents.find(
       (c) => c.name === componentName
@@ -3316,24 +3844,30 @@ var VisionManager = class _VisionManager {
       cache_dir: this.modelsDir
     };
   }
+  /**
+   * Asynchronous method to initialize the vision model by loading Florence2 model, vision tokenizer, and vision processor.
+   *
+   * @returns {Promise<void>} - Promise that resolves once the initialization process is completed.
+   * @throws {Error} - If there is an error during the initialization process.
+   */
   async initialize() {
     try {
       if (this.initialized) {
-        logger8.info(
+        logger9.info(
           "Vision model already initialized, skipping initialization"
         );
         return;
       }
-      logger8.info("Starting vision model initialization...");
+      logger9.info("Starting vision model initialization...");
       const modelSpec = MODEL_SPECS.vision;
-      logger8.info("Configuring environment for vision model...");
+      logger9.info("Configuring environment for vision model...");
       env.allowLocalModels = true;
       env.allowRemoteModels = true;
       if (this.platformConfig.useOnnx) {
         env.backends.onnx.enabled = true;
         env.backends.onnx.logLevel = "info";
       }
-      logger8.info("Loading Florence2 model...");
+      logger9.info("Loading Florence2 model...");
       try {
         let lastProgress = -1;
         const modelCached = this.checkCacheExists(modelSpec.modelId, "model");
@@ -3355,7 +3889,7 @@ var VisionManager = class _VisionManager {
                   currentProgress / 100 * barLength
                 );
                 const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-                logger8.info(
+                logger9.info(
                   `Downloading vision model: ${progressBar} ${currentProgress}%`
                 );
                 if (currentProgress === 100) this.modelDownloaded = true;
@@ -3364,16 +3898,16 @@ var VisionManager = class _VisionManager {
           }
         );
         this.model = model;
-        logger8.success("Florence2 model loaded successfully");
+        logger9.success("Florence2 model loaded successfully");
       } catch (error) {
-        logger8.error("Failed to load Florence2 model:", {
+        logger9.error("Failed to load Florence2 model:", {
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : void 0,
           modelId: modelSpec.modelId
         });
         throw error;
       }
-      logger8.info("Loading vision tokenizer...");
+      logger9.info("Loading vision tokenizer...");
       try {
         const tokenizerCached = this.checkCacheExists(
           modelSpec.modelId,
@@ -3396,7 +3930,7 @@ var VisionManager = class _VisionManager {
                   currentProgress / 100 * barLength
                 );
                 const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-                logger8.info(
+                logger9.info(
                   `Downloading vision tokenizer: ${progressBar} ${currentProgress}%`
                 );
                 if (currentProgress === 100) this.tokenizerDownloaded = true;
@@ -3404,16 +3938,16 @@ var VisionManager = class _VisionManager {
             }
           }
         );
-        logger8.success("Vision tokenizer loaded successfully");
+        logger9.success("Vision tokenizer loaded successfully");
       } catch (error) {
-        logger8.error("Failed to load tokenizer:", {
+        logger9.error("Failed to load tokenizer:", {
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : void 0,
           modelId: modelSpec.modelId
         });
         throw error;
       }
-      logger8.info("Loading vision processor...");
+      logger9.info("Loading vision processor...");
       try {
         const processorCached = this.checkCacheExists(
           modelSpec.modelId,
@@ -3437,7 +3971,7 @@ var VisionManager = class _VisionManager {
                   currentProgress / 100 * barLength
                 );
                 const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-                logger8.info(
+                logger9.info(
                   `Downloading vision processor: ${progressBar} ${currentProgress}%`
                 );
                 if (currentProgress === 100) this.processorDownloaded = true;
@@ -3445,9 +3979,9 @@ var VisionManager = class _VisionManager {
             }
           }
         );
-        logger8.success("Vision processor loaded successfully");
+        logger9.success("Vision processor loaded successfully");
       } catch (error) {
-        logger8.error("Failed to load vision processor:", {
+        logger9.error("Failed to load vision processor:", {
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : void 0,
           modelId: modelSpec.modelId
@@ -3455,9 +3989,9 @@ var VisionManager = class _VisionManager {
         throw error;
       }
       this.initialized = true;
-      logger8.success("Vision model initialization complete");
+      logger9.success("Vision model initialization complete");
     } catch (error) {
-      logger8.error("Vision model initialization failed:", {
+      logger9.error("Vision model initialization failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         modelsDir: this.modelsDir
@@ -3465,15 +3999,21 @@ var VisionManager = class _VisionManager {
       throw error;
     }
   }
+  /**
+   * Fetches an image from a given URL and returns the image data as a Buffer along with its MIME type.
+   *
+   * @param {string} url - The URL of the image to fetch.
+   * @returns {Promise<{ buffer: Buffer; mimeType: string }>} Object containing the image data as a Buffer and its MIME type.
+   */
   async fetchImage(url) {
     try {
-      logger8.info(`Fetching image from URL: ${url.slice(0, 100)}...`);
+      logger9.info(`Fetching image from URL: ${url.slice(0, 100)}...`);
       if (url.startsWith("data:")) {
-        logger8.info("Processing data URL...");
+        logger9.info("Processing data URL...");
         const [header, base64Data] = url.split(",");
         const mimeType2 = header.split(";")[0].split(":")[1];
         const buffer2 = Buffer.from(base64Data, "base64");
-        logger8.info("Data URL processed successfully");
+        logger9.info("Data URL processed successfully");
         return { buffer: buffer2, mimeType: mimeType2 };
       }
       const response = await fetch(url);
@@ -3482,14 +4022,14 @@ var VisionManager = class _VisionManager {
       }
       const buffer = Buffer.from(await response.arrayBuffer());
       const mimeType = response.headers.get("content-type") || "image/jpeg";
-      logger8.info("Image fetched successfully:", {
+      logger9.info("Image fetched successfully:", {
         mimeType,
         bufferSize: buffer.length,
         status: response.status
       });
       return { buffer, mimeType };
     } catch (error) {
-      logger8.error("Failed to fetch image:", {
+      logger9.error("Failed to fetch image:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         url
@@ -3497,39 +4037,44 @@ var VisionManager = class _VisionManager {
       throw error;
     }
   }
+  /**
+   * Processes the image from the provided URL using the initialized vision model components.
+   * @param {string} imageUrl - The URL of the image to process.
+   * @returns {Promise<{ title: string; description: string }>} An object containing the title and description of the processed image.
+   */
   async processImage(imageUrl) {
     try {
-      logger8.info("Starting image processing...");
+      logger9.info("Starting image processing...");
       if (!this.initialized) {
-        logger8.info("Vision model not initialized, initializing now...");
+        logger9.info("Vision model not initialized, initializing now...");
         await this.initialize();
       }
       if (!this.model || !this.processor || !this.tokenizer) {
         throw new Error("Vision model components not properly initialized");
       }
-      logger8.info("Fetching image...");
+      logger9.info("Fetching image...");
       const { buffer, mimeType } = await this.fetchImage(imageUrl);
-      logger8.info("Creating image blob...");
+      logger9.info("Creating image blob...");
       const blob = new Blob([buffer], { type: mimeType });
-      logger8.info("Converting blob to RawImage...");
+      logger9.info("Converting blob to RawImage...");
       const image = await RawImage.fromBlob(blob);
-      logger8.info("Processing image with vision processor...");
+      logger9.info("Processing image with vision processor...");
       const visionInputs = await this.processor(image);
-      logger8.info("Constructing prompts...");
+      logger9.info("Constructing prompts...");
       const prompts = this.processor.construct_prompts("<DETAILED_CAPTION>");
-      logger8.info("Tokenizing prompts...");
+      logger9.info("Tokenizing prompts...");
       const textInputs = this.tokenizer(prompts);
-      logger8.info("Generating image description...");
+      logger9.info("Generating image description...");
       const generatedIds = await this.model.generate({
         ...textInputs,
         ...visionInputs,
         max_new_tokens: MODEL_SPECS.vision.maxTokens
       });
-      logger8.info("Decoding generated text...");
+      logger9.info("Decoding generated text...");
       const generatedText = this.tokenizer.batch_decode(generatedIds, {
         skip_special_tokens: false
       })[0];
-      logger8.info("Post-processing generation...");
+      logger9.info("Post-processing generation...");
       const result = this.processor.post_process_generation(
         generatedText,
         "<DETAILED_CAPTION>",
@@ -3540,103 +4085,25 @@ var VisionManager = class _VisionManager {
         title: `${detailedCaption.split(".")[0]}.`,
         description: detailedCaption
       };
-      logger8.success("Image processing complete:", {
+      logger9.success("Image processing complete:", {
         titleLength: response.title.length,
         descriptionLength: response.description.length
       });
       return response;
     } catch (error) {
-      logger8.error("Image processing failed:", {
+      logger9.error("Image processing failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         imageUrl,
         modelInitialized: this.initialized,
         hasModel: !!this.model,
-        hasProcessor: !!this.processor,
-        hasTokenizer: !!this.tokenizer
-      });
-      throw error;
-    }
-  }
-};
-
-// src/environment.ts
-import { z } from "zod";
-import { logger as logger9 } from "@elizaos/core";
-var configSchema = z.object({
-  USE_LOCAL_AI: z.boolean().default(true),
-  USE_STUDIOLM_TEXT_MODELS: z.boolean().default(false),
-  USE_OLLAMA_TEXT_MODELS: z.boolean().default(false),
-  // Ollama Configuration
-  OLLAMA_SERVER_URL: z.string().default("http://localhost:11434"),
-  OLLAMA_MODEL: z.string().default("deepseek-r1-distill-qwen-7b"),
-  USE_OLLAMA_EMBEDDING: z.boolean().default(false),
-  OLLAMA_EMBEDDING_MODEL: z.string().default(""),
-  SMALL_OLLAMA_MODEL: z.string().default("deepseek-r1:1.5b"),
-  MEDIUM_OLLAMA_MODEL: z.string().default("deepseek-r1:7b"),
-  LARGE_OLLAMA_MODEL: z.string().default("deepseek-r1:7b"),
-  // StudioLM Configuration
-  STUDIOLM_SERVER_URL: z.string().default("http://localhost:1234"),
-  STUDIOLM_SMALL_MODEL: z.string().default("lmstudio-community/deepseek-r1-distill-qwen-1.5b"),
-  STUDIOLM_MEDIUM_MODEL: z.string().default("deepseek-r1-distill-qwen-7b"),
-  STUDIOLM_EMBEDDING_MODEL: z.union([z.boolean(), z.string()]).default(false)
-});
-function validateModelConfig(config) {
-  logger9.info("Validating model configuration with values:", {
-    USE_LOCAL_AI: config.USE_LOCAL_AI,
-    USE_STUDIOLM_TEXT_MODELS: config.USE_STUDIOLM_TEXT_MODELS,
-    USE_OLLAMA_TEXT_MODELS: config.USE_OLLAMA_TEXT_MODELS
-  });
-  if (!config.USE_LOCAL_AI) {
-    config.USE_LOCAL_AI = true;
-    logger9.info("Setting USE_LOCAL_AI to true as it's required");
-  }
-  if (config.USE_STUDIOLM_TEXT_MODELS && config.USE_OLLAMA_TEXT_MODELS) {
-    throw new Error(
-      "StudioLM and Ollama text models cannot be enabled simultaneously"
-    );
-  }
-  logger9.info("Configuration is valid");
-}
-async function validateConfig(config) {
-  try {
-    const booleanConfig = {
-      USE_LOCAL_AI: true,
-      // Always true
-      USE_STUDIOLM_TEXT_MODELS: config.USE_STUDIOLM_TEXT_MODELS === "true",
-      USE_OLLAMA_TEXT_MODELS: config.USE_OLLAMA_TEXT_MODELS === "true",
-      USE_OLLAMA_EMBEDDING: config.USE_OLLAMA_EMBEDDING === "true"
-    };
-    validateModelConfig(booleanConfig);
-    const fullConfig = {
-      ...booleanConfig,
-      OLLAMA_SERVER_URL: config.OLLAMA_SERVER_URL || "http://localhost:11434",
-      OLLAMA_MODEL: config.OLLAMA_MODEL || "deepseek-r1-distill-qwen-7b",
-      OLLAMA_EMBEDDING_MODEL: config.OLLAMA_EMBEDDING_MODEL || "",
-      SMALL_OLLAMA_MODEL: config.SMALL_OLLAMA_MODEL || "deepseek-r1:1.5b",
-      MEDIUM_OLLAMA_MODEL: config.MEDIUM_OLLAMA_MODEL || "deepseek-r1:7b",
-      LARGE_OLLAMA_MODEL: config.LARGE_OLLAMA_MODEL || "deepseek-r1:7b",
-      STUDIOLM_SERVER_URL: config.STUDIOLM_SERVER_URL || "http://localhost:1234",
-      STUDIOLM_SMALL_MODEL: config.STUDIOLM_SMALL_MODEL || "lmstudio-community/deepseek-r1-distill-qwen-1.5b",
-      STUDIOLM_MEDIUM_MODEL: config.STUDIOLM_MEDIUM_MODEL || "deepseek-r1-distill-qwen-7b",
-      STUDIOLM_EMBEDDING_MODEL: config.STUDIOLM_EMBEDDING_MODEL || false
-    };
-    const validatedConfig = configSchema.parse(fullConfig);
-    return validatedConfig;
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n");
-      logger9.error("Zod validation failed:", errorMessages);
-      throw new Error(`Configuration validation failed:
-${errorMessages}`);
+        hasProcessor: !!this.processor,
+        hasTokenizer: !!this.tokenizer
+      });
+      throw error;
     }
-    logger9.error("Configuration validation failed:", {
-      error: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : void 0
-    });
-    throw error;
   }
-}
+};
 
 // src/index.ts
 var __filename = fileURLToPath(import.meta.url);
@@ -3711,141 +4178,87 @@ var LocalAIManager = class _LocalAIManager {
   ttsManager;
   studioLMManager;
   ollamaManager;
+  // Initialization state flags
   ollamaInitialized = false;
   studioLMInitialized = false;
+  smallModelInitialized = false;
+  mediumModelInitialized = false;
+  embeddingInitialized = false;
+  visionInitialized = false;
+  transcriptionInitialized = false;
+  ttsInitialized = false;
+  // Initialization promises to prevent duplicate initialization
+  smallModelInitializingPromise = null;
+  mediumModelInitializingPromise = null;
+  embeddingInitializingPromise = null;
+  visionInitializingPromise = null;
+  transcriptionInitializingPromise = null;
+  ttsInitializingPromise = null;
+  ollamaInitializingPromise = null;
+  studioLMInitializingPromise = null;
   modelsDir;
+  /**
+   * Private constructor function to initialize base managers and paths.
+   * This now only sets up the basic infrastructure without loading any models.
+   */
   constructor() {
     const modelsDir = path5.join(process.cwd(), "models");
-    this.activeModelConfig = MODEL_SPECS.small;
-    this.modelPath = path5.join(modelsDir, MODEL_SPECS.small.name);
-    this.mediumModelPath = path5.join(modelsDir, MODEL_SPECS.medium.name);
-    this.cacheDir = path5.join(process.cwd(), "./cache");
-    this.modelsDir = modelsDir;
-    this.downloadManager = DownloadManager.getInstance(
-      this.cacheDir,
-      this.modelsDir
+    if (process.env.LLAMALOCAL_PATH?.trim()) {
+      this.modelsDir = path5.resolve(process.env.LLAMALOCAL_PATH.trim());
+    } else {
+      if (!fs5.existsSync(modelsDir)) {
+        fs5.mkdirSync(modelsDir, { recursive: true });
+        logger10.info("Created models directory");
+      }
+      this.modelsDir = modelsDir;
+    }
+    this.modelPath = path5.join(
+      this.modelsDir,
+      "DeepSeek-R1-Distill-Qwen-1.5B-Q8_0.gguf"
     );
-    this.tokenizerManager = TokenizerManager.getInstance(
-      this.cacheDir,
-      this.modelsDir
+    this.mediumModelPath = path5.join(
+      this.modelsDir,
+      "DeepSeek-R1-Distill-Qwen-7B-Q5_K_M.gguf"
     );
-    this.visionManager = VisionManager.getInstance(this.cacheDir);
-    this.transcribeManager = TranscribeManager.getInstance(this.cacheDir);
-    this.ttsManager = TTSManager.getInstance(this.cacheDir);
+    const cacheDirEnv = process.env.CACHE_DIR?.trim();
+    if (cacheDirEnv) {
+      this.cacheDir = path5.resolve(cacheDirEnv);
+    } else {
+      const cacheDir = path5.join(process.cwd(), "cache");
+      if (!fs5.existsSync(cacheDir)) {
+        fs5.mkdirSync(cacheDir, { recursive: true });
+        logger10.info("Ensuring cache directory exists:", cacheDir);
+      }
+      this.cacheDir = cacheDir;
+    }
+    this.downloadManager = DownloadManager.getInstance();
+    this.tokenizerManager = TokenizerManager.getInstance();
+    this.visionManager = VisionManager.getInstance();
+    this.transcribeManager = TranscribeManager.getInstance();
+    this.ttsManager = TTSManager.getInstance();
     if (process.env.USE_STUDIOLM_TEXT_MODELS === "true") {
-      logger10.info(
-        "Creating StudioLM manager instance (enabled in environment)"
-      );
       this.studioLMManager = StudioLMManager.getInstance();
-    } else {
-      logger10.info(
-        "StudioLM manager instance not created (disabled in environment)"
-      );
     }
     if (process.env.USE_OLLAMA_TEXT_MODELS === "true") {
-      logger10.info("Creating Ollama manager instance (enabled in environment)");
       this.ollamaManager = OllamaManager.getInstance();
-    } else {
-      logger10.info(
-        "Ollama manager instance not created (disabled in environment)"
-      );
-    }
-    this.initializeEnvironment().catch((error) => {
-      logger10.error("Environment initialization failed:", error);
-      throw error;
-    });
-    this.checkPlatformCapabilities().catch((error) => {
-      logger10.warn("Platform capabilities check failed:", error);
-    });
-    this.initializeEmbedding().catch((error) => {
-      logger10.warn("Embedding initialization failed:", error);
-    });
-    logger10.info("Starting model initialization sequence");
-    this.initialize(ModelTypes3.TEXT_SMALL).then(() => {
-      logger10.info(
-        "Small model initialization complete, starting large model initialization"
-      );
-      return this.initialize(ModelTypes3.TEXT_LARGE);
-    }).catch((error) => {
-      logger10.warn("Models initialization failed:", {
-        stack: error instanceof Error ? error.stack : void 0,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    });
-    const servicePromises = [
-      // Add vision initialization using a public method
-      this.initializeVision().catch((error) => {
-        logger10.warn("Vision initialization failed:", error);
-        return null;
-      }),
-      // Add transcription initialization with better error handling
-      this.initializeTranscription().catch((error) => {
-        logger10.warn("Transcription initialization failed:", {
-          error: error instanceof Error ? error.message : String(error),
-          stack: error instanceof Error ? error.stack : void 0
-        });
-        return null;
-      }),
-      // Add TTS initialization
-      this.initializeTTS().catch((error) => {
-        logger10.warn("TTS initialization failed:", {
-          error: error instanceof Error ? error.message : String(error),
-          stack: error instanceof Error ? error.stack : void 0
-        });
-        return null;
-      })
-    ];
-    if (process.env.USE_STUDIOLM_TEXT_MODELS === "true" && this.studioLMManager) {
-      logger10.info(
-        "StudioLM initialization enabled by environment configuration"
-      );
-      servicePromises.push(
-        this.initializeStudioLM().then(() => {
-          this.studioLMInitialized = true;
-        }).catch((error) => {
-          logger10.warn("StudioLM initialization failed:", {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : void 0
-          });
-          return null;
-        })
-      );
-    } else {
-      logger10.info(
-        "StudioLM initialization skipped (disabled in environment configuration or manager not created)"
-      );
-    }
-    if (process.env.USE_OLLAMA_TEXT_MODELS === "true" && this.ollamaManager) {
-      logger10.info("Ollama initialization enabled by environment configuration");
-      servicePromises.push(
-        this.initializeOllama().then(() => {
-          this.ollamaInitialized = true;
-        }).catch((error) => {
-          logger10.warn("Ollama initialization failed:", {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : void 0
-          });
-          return null;
-        })
-      );
-    } else {
-      logger10.info(
-        "Ollama initialization skipped (disabled in environment configuration or manager not created)"
-      );
     }
-    Promise.all(servicePromises).catch((error) => {
-      logger10.warn("Models initialization failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0
-      });
-    });
+    this.activeModelConfig = MODEL_SPECS.small;
   }
+  /**
+   * 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 the environment variables with the validated values.
+   *
+   * @returns {Promise<void>} A Promise that resolves once the environment has been successfully initialized.
+   */
   async initializeEnvironment() {
     try {
       logger10.info("Validating environment configuration...");
@@ -3872,6 +4285,12 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
+  /**
+   * Asynchronously initializes the Ollama model.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the initialization is complete.
+   * @throws {Error} If the Ollama manager is not created, or if initialization of Ollama models fails.
+   */
   async initializeOllama() {
     try {
       logger10.info("Initializing Ollama models...");
@@ -3894,6 +4313,11 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
+  /**
+   * Initializes StudioLM model with error handling.
+   * @returns A Promise that resolves when the initialization is complete.
+   * @throws {Error} If StudioLM manager is not created, initialization fails, or models are not properly loaded.
+   */
   async initializeStudioLM() {
     try {
       logger10.info("Initializing StudioLM models...");
@@ -3917,130 +4341,12 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
-  async initializeTranscription() {
-    try {
-      logger10.info("Initializing transcription model...");
-      const ffmpegAvailable = await this.transcribeManager.ensureFFmpeg();
-      if (!ffmpegAvailable) {
-        throw new Error(
-          "Cannot initialize transcription without FFmpeg. Please install FFmpeg and try again."
-        );
-      }
-      const samplePath = path5.join(this.cacheDir, "sample1.wav");
-      const awsSampleUrl = "https://d2908q01vomqb2.cloudfront.net/artifacts/DBSBlogs/ML-15311/sample1.wav?_=1";
-      if (!fs5.existsSync(samplePath)) {
-        logger10.info(
-          "Sample WAV file not found in cache, downloading from AWS..."
-        );
-        try {
-          await this.downloadManager.downloadFromUrl(awsSampleUrl, samplePath);
-          logger10.success("Sample WAV file downloaded successfully");
-        } catch (downloadError) {
-          logger10.error("Failed to download sample WAV file:", {
-            error: downloadError instanceof Error ? downloadError.message : String(downloadError),
-            url: awsSampleUrl,
-            destination: samplePath,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          throw downloadError;
-        }
-      } else {
-        logger10.info("Sample WAV file already exists in cache");
-      }
-      if (!fs5.existsSync(samplePath)) {
-        throw new Error(
-          `Sample audio file not found at: ${samplePath} after download attempt`
-        );
-      }
-      const testAudioBuffer = fs5.readFileSync(samplePath);
-      const result = await this.transcribeAudio(testAudioBuffer);
-      logger10.info("Test transcription result:", {
-        text: result,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      logger10.success("Transcription model initialization complete");
-    } catch (error) {
-      logger10.error("Transcription initialization failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    }
-  }
-  async initializeVision() {
-    try {
-      logger10.info("Initializing vision model...");
-      const awsImageUrl = "https://d1.awsstatic.com/product-marketing/Rekognition/Image%20for%20facial%20analysis.3fcc22e8451b4a238540128cb5510b8cbe22da51.jpg";
-      const imagePath = path5.join(this.cacheDir, "test_image.jpg");
-      if (!fs5.existsSync(imagePath)) {
-        logger10.info("Downloading test image from AWS...");
-        try {
-          await this.downloadManager.downloadFromUrl(awsImageUrl, imagePath);
-          logger10.success("Test image downloaded successfully");
-        } catch (downloadError) {
-          logger10.error("Failed to download test image:", {
-            error: downloadError instanceof Error ? downloadError.message : String(downloadError),
-            url: awsImageUrl,
-            destination: imagePath
-          });
-          throw downloadError;
-        }
-      } else {
-        logger10.info("Test image already exists in cache");
-      }
-      if (!fs5.existsSync(imagePath)) {
-        throw new Error(
-          `Test image not found at: ${imagePath} after download attempt`
-        );
-      }
-      const imageBuffer = fs5.readFileSync(imagePath);
-      const result = await this.describeImage(imageBuffer, "image/jpeg");
-      logger10.info("Test image description:", result);
-      logger10.success("Vision model initialization complete");
-    } catch (error) {
-      logger10.error("Vision initialization failed:", error);
-      throw error;
-    }
-  }
-  async initializeTTS() {
-    try {
-      logger10.info("Initializing TTS model...");
-      const testText = "ElizaOS is yours";
-      logger10.info("Testing TTS with sample text:", { text: testText });
-      const audioStream = await this.ttsManager.generateSpeech(testText);
-      if (!(audioStream instanceof Readable2)) {
-        throw new Error("TTS did not return a valid audio stream");
-      }
-      let dataReceived = false;
-      await new Promise((resolve, reject) => {
-        audioStream.on("data", () => {
-          if (!dataReceived) {
-            dataReceived = true;
-            logger10.info("TTS audio stream is producing data");
-          }
-        });
-        audioStream.on("end", () => {
-          if (!dataReceived) {
-            reject(new Error("No audio data received from TTS stream"));
-          } else {
-            resolve();
-          }
-        });
-        audioStream.on("error", (err) => {
-          reject(err);
-        });
-      });
-      logger10.success("TTS model initialization complete");
-    } catch (error) {
-      logger10.error("TTS initialization failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    }
-  }
+  /**
+   * Downloads the model based on the modelPath provided.
+   * Determines whether to download a large or small model based on the current modelPath.
+   *
+   * @returns A Promise that resolves to a boolean indicating whether the model download was successful.
+   */
   async downloadModel() {
     try {
       const isLargeModel = this.modelPath === this.mediumModelPath;
@@ -4057,6 +4363,11 @@ var LocalAIManager = class _LocalAIManager {
       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();
@@ -4072,65 +4383,24 @@ var LocalAIManager = class _LocalAIManager {
       logger10.warn("Platform detection failed:", error);
     }
   }
+  /**
+   * Initializes the LocalAI Manager for a given model type.
+   *
+   * @param {ModelType} modelType - The type of model to initialize (default: ModelTypes.TEXT_SMALL)
+   * @returns {Promise<void>} A promise that resolves when initialization is complete or rejects if an error occurs
+   */
   async initialize(modelType = ModelTypes3.TEXT_SMALL) {
-    try {
-      logger10.info("Initializing LocalAI Manager for model class:", modelType);
-      if (modelType === ModelTypes3.TEXT_LARGE) {
-        this.modelPath = this.mediumModelPath;
-        logger10.info("Using medium model path:", this.modelPath);
-      } else {
-        this.modelPath = path5.join(this.modelsDir, MODEL_SPECS.small.name);
-        logger10.info("Using small model path:", this.modelPath);
-      }
-      const wasNewlyDownloaded = await this.downloadModel();
-      if (wasNewlyDownloaded) {
-        if (modelType === ModelTypes3.TEXT_LARGE) {
-          logger10.info(
-            "Adding delay before loading large model to ensure download is complete..."
-          );
-          await new Promise((resolve) => setTimeout(resolve, 1e4));
-        } else {
-          logger10.info(
-            "Adding delay before loading small model to ensure download is complete..."
-          );
-          await new Promise((resolve) => setTimeout(resolve, 1e4));
-        }
-      }
-      if (!fs5.existsSync(this.modelPath)) {
-        throw new Error(`Model file not found at path: ${this.modelPath}`);
-      }
-      this.llama = await getLlama2();
-      if (modelType === ModelTypes3.TEXT_LARGE) {
-        this.activeModelConfig = MODEL_SPECS.medium;
-        logger10.info("Loading large model from:", this.modelPath);
-        this.mediumModel = await this.llama.loadModel({
-          modelPath: this.modelPath
-        });
-        this.ctx = await this.mediumModel.createContext({
-          contextSize: MODEL_SPECS.medium.contextSize
-        });
-      } else {
-        this.activeModelConfig = MODEL_SPECS.small;
-        logger10.info("Loading small model from:", this.modelPath);
-        this.smallModel = await this.llama.loadModel({
-          modelPath: this.modelPath
-        });
-        this.ctx = await this.smallModel.createContext({
-          contextSize: MODEL_SPECS.small.contextSize
-        });
-      }
-      if (!this.ctx) {
-        throw new Error("Failed to create prompt");
-      }
-      this.sequence = this.ctx.getSequence();
-      logger10.success(
-        `Model initialization complete for ${modelType === ModelTypes3.TEXT_LARGE ? "large" : "small"} model`
-      );
-    } catch (error) {
-      logger10.error("Initialization failed:", error);
-      throw error;
+    if (modelType === ModelTypes3.TEXT_LARGE) {
+      await this.lazyInitMediumModel();
+    } else {
+      await this.lazyInitSmallModel();
     }
   }
+  /**
+   * Asynchronously initializes the embedding model.
+   *
+   * @returns {Promise<void>} A promise that resolves once the initialization is complete.
+   */
   async initializeEmbedding() {
     try {
       logger10.info("Initializing embedding model...");
@@ -4159,13 +4429,6 @@ var LocalAIManager = class _LocalAIManager {
         logger10.info(`Downloading embedding model: ${completedBar} 100%`);
         logger10.success("FlagEmbedding instance created successfully");
       }
-      logger10.info("Testing embedding model with sample text...");
-      const testEmbed = await this.embeddingModel.queryEmbed("test");
-      logger10.info(
-        "Test embedding generated successfully, dimensions:",
-        testEmbed.length
-      );
-      logger10.success("Embedding model initialization complete");
     } catch (error) {
       logger10.error("Embedding initialization failed with details:", {
         error: error instanceof Error ? error.message : String(error),
@@ -4176,6 +4439,12 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
+  /**
+   * Asynchronously generates text using either StudioLM or Ollama models based on the specified parameters.
+   *
+   * @param {GenerateTextParams} params - The parameters for generating the text.
+   * @returns {Promise<string>} - A promise that resolves to the generated text.
+   */
   async generateTextOllamaStudio(params) {
     try {
       const modelConfig = this.getTextModelSource();
@@ -4242,28 +4511,30 @@ var LocalAIManager = class _LocalAIManager {
       return this.generateText(params);
     }
   }
+  /**
+   * Asynchronously generates text based on the provided parameters.
+   * Now uses lazy initialization for models
+   */
   async generateText(params) {
     try {
-      if (!this.sequence || !this.smallModel || params.modelType === ModelTypes3.TEXT_LARGE && !this.mediumModel) {
-        await this.initialize(params.modelType);
-      }
-      let activeModel;
       if (params.modelType === ModelTypes3.TEXT_LARGE) {
+        await this.lazyInitMediumModel();
         if (!this.mediumModel) {
-          throw new Error("Medium model not initialized");
+          throw new Error("Medium model initialization failed");
         }
         this.activeModelConfig = MODEL_SPECS.medium;
-        activeModel = this.mediumModel;
-        this.ctx = await activeModel.createContext({
+        const mediumModel = this.mediumModel;
+        this.ctx = await mediumModel.createContext({
           contextSize: MODEL_SPECS.medium.contextSize
         });
       } else {
+        await this.lazyInitSmallModel();
         if (!this.smallModel) {
-          throw new Error("Small model not initialized");
+          throw new Error("Small model initialization failed");
         }
         this.activeModelConfig = MODEL_SPECS.small;
-        activeModel = this.smallModel;
-        this.ctx = await activeModel.createContext({
+        const smallModel = this.smallModel;
+        this.ctx = await smallModel.createContext({
           contextSize: MODEL_SPECS.small.contextSize
         });
       }
@@ -4300,7 +4571,7 @@ var LocalAIManager = class _LocalAIManager {
         temperature: 0.7,
         topP: 0.9,
         repeatPenalty: {
-          punishTokensFilter: () => activeModel.tokenize(wordsToPunish.join(" ")),
+          punishTokensFilter: () => this.smallModel.tokenize(wordsToPunish.join(" ")),
           penalty: 1.2,
           frequencyPenalty: 0.7,
           presencePenalty: 0.7
@@ -4322,19 +4593,12 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
+  /**
+   * Generate embeddings - now with lazy initialization
+   */
   async generateEmbedding(text) {
     try {
-      logger10.info("Generating embedding...");
-      if (!text) {
-        throw new Error("Input text cannot be null or undefined");
-      }
-      logger10.debug("Input text length:", text.length);
-      if (!this.embeddingModel) {
-        logger10.error(
-          "Embedding model not initialized, attempting to initialize..."
-        );
-        await this.initializeEmbedding();
-      }
+      await this.lazyInitEmbedding();
       if (!this.embeddingModel) {
         throw new Error("Failed to initialize embedding model");
       }
@@ -4353,8 +4617,12 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
+  /**
+   * Describe image with lazy vision model initialization
+   */
   async describeImage(imageData, mimeType) {
     try {
+      await this.lazyInitVision();
       const base64 = imageData.toString("base64");
       const dataUrl = `data:${mimeType};base64,${base64}`;
       return await this.visionManager.processImage(dataUrl);
@@ -4363,8 +4631,12 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
+  /**
+   * Transcribe audio with lazy transcription model initialization
+   */
   async transcribeAudio(audioBuffer) {
     try {
+      await this.lazyInitTranscription();
       const result = await this.transcribeManager.transcribe(audioBuffer);
       return result.text;
     } catch (error) {
@@ -4375,8 +4647,12 @@ var LocalAIManager = class _LocalAIManager {
       throw error;
     }
   }
+  /**
+   * Generate speech with lazy TTS model initialization
+   */
   async generateSpeech(text) {
     try {
+      await this.lazyInitTTS();
       return await this.ttsManager.generateSpeech(text);
     } catch (error) {
       logger10.error("Speech generation failed:", {
@@ -4387,12 +4663,25 @@ var LocalAIManager = class _LocalAIManager {
     }
   }
   // Add public accessor methods
+  /**
+   * 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;
   }
+  /**
+   * Retrieves the source configuration for the text model based on environment variables and manager existence.
+   * @returns {TextModelConfig} The configuration object containing the text model source and type.
+   */
   getTextModelSource() {
     try {
       const config = {
@@ -4411,19 +4700,211 @@ var LocalAIManager = class _LocalAIManager {
       return { source: "local", modelType: ModelTypes3.TEXT_SMALL };
     }
   }
+  /**
+   * Generic lazy initialization handler for any model type
+   */
+  async lazyInitialize(modelType, isInitialized, initPromise, initFunction) {
+    if (isInitialized) {
+      return Promise.resolve(null);
+    }
+    if (initPromise) {
+      logger10.info(`Waiting for ${modelType} initialization to complete...`);
+      await initPromise;
+      return Promise.resolve(null);
+    }
+    logger10.info(`Lazy initializing ${modelType}...`);
+    return initFunction();
+  }
+  /**
+   * Lazy initialize the small text model
+   */
+  async lazyInitSmallModel() {
+    if (this.smallModelInitialized) return;
+    if (!this.smallModelInitializingPromise) {
+      this.smallModelInitializingPromise = (async () => {
+        await this.initializeEnvironment();
+        await this.checkPlatformCapabilities();
+        await this.downloadModel();
+        try {
+          this.llama = await getLlama2();
+          const smallModel = await this.llama.loadModel(this.modelPath, {
+            gpuLayers: 43,
+            embeddings: true,
+            vocabOnly: false
+          });
+          this.smallModel = smallModel;
+          const ctx = await smallModel.createContext({
+            contextSize: MODEL_SPECS.small.contextSize
+          });
+          this.ctx = ctx;
+          this.sequence = void 0;
+          this.smallModelInitialized = true;
+          logger10.info("Small model initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize small model:", error);
+          this.smallModelInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.smallModelInitializingPromise;
+  }
+  /**
+   * Lazy initialize the medium text model
+   */
+  async lazyInitMediumModel() {
+    if (this.mediumModelInitialized) return;
+    if (!this.mediumModelInitializingPromise) {
+      this.mediumModelInitializingPromise = (async () => {
+        if (!this.llama) {
+          await this.lazyInitSmallModel();
+        }
+        try {
+          const mediumModel = await this.llama.loadModel(
+            this.mediumModelPath,
+            {
+              gpuLayers: 43,
+              embeddings: true,
+              vocabOnly: false
+            }
+          );
+          this.mediumModel = mediumModel;
+          this.mediumModelInitialized = true;
+          logger10.info("Medium model initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize medium model:", error);
+          this.mediumModelInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.mediumModelInitializingPromise;
+  }
+  /**
+   * Lazy initialize the embedding model
+   */
+  async lazyInitEmbedding() {
+    if (this.embeddingInitialized) return;
+    if (!this.embeddingInitializingPromise) {
+      this.embeddingInitializingPromise = (async () => {
+        try {
+          await this.initializeEmbedding();
+          this.embeddingInitialized = true;
+          logger10.info("Embedding model initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize embedding model:", error);
+          this.embeddingInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.embeddingInitializingPromise;
+  }
+  /**
+   * Lazy initialize the vision model
+   */
+  async lazyInitVision() {
+    if (this.visionInitialized) return;
+    if (!this.visionInitializingPromise) {
+      this.visionInitializingPromise = (async () => {
+        try {
+          this.visionInitialized = true;
+          logger10.info("Vision model initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize vision model:", error);
+          this.visionInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.visionInitializingPromise;
+  }
+  /**
+   * Lazy initialize the transcription model
+   */
+  async lazyInitTranscription() {
+    if (this.transcriptionInitialized) return;
+    if (!this.transcriptionInitializingPromise) {
+      this.transcriptionInitializingPromise = (async () => {
+        try {
+          this.transcriptionInitialized = true;
+          logger10.info("Transcription model initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize transcription model:", error);
+          this.transcriptionInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.transcriptionInitializingPromise;
+  }
+  /**
+   * Lazy initialize the TTS model
+   */
+  async lazyInitTTS() {
+    if (this.ttsInitialized) return;
+    if (!this.ttsInitializingPromise) {
+      this.ttsInitializingPromise = (async () => {
+        try {
+          this.ttsInitialized = true;
+          logger10.info("TTS model initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize TTS model:", error);
+          this.ttsInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.ttsInitializingPromise;
+  }
+  /**
+   * Lazy initialize the Ollama integration
+   */
+  async lazyInitOllama() {
+    if (this.ollamaInitialized) return;
+    if (!this.ollamaInitializingPromise) {
+      this.ollamaInitializingPromise = (async () => {
+        try {
+          await this.initializeOllama();
+          this.ollamaInitialized = true;
+          logger10.info("Ollama initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize Ollama:", error);
+          this.ollamaInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.ollamaInitializingPromise;
+  }
+  /**
+   * Lazy initialize the StudioLM integration
+   */
+  async lazyInitStudioLM() {
+    if (this.studioLMInitialized) return;
+    if (!this.studioLMInitializingPromise) {
+      this.studioLMInitializingPromise = (async () => {
+        try {
+          await this.initializeStudioLM();
+          this.studioLMInitialized = true;
+          logger10.info("StudioLM initialized successfully");
+        } catch (error) {
+          logger10.error("Failed to initialize StudioLM:", error);
+          this.studioLMInitializingPromise = null;
+          throw error;
+        }
+      })();
+    }
+    await this.studioLMInitializingPromise;
+  }
 };
 var localAIManager = LocalAIManager.getInstance();
 var localAIPlugin = {
   name: "local-ai",
   description: "Local AI plugin using LLaMA models",
-  async init(config) {
+  async init() {
     try {
       logger10.info("Initializing local-ai plugin...");
-      const validatedConfig = await validateConfig(config);
-      for (const [key, value] of Object.entries(validatedConfig)) {
-        process.env[key] = String(value);
-        logger10.debug(`Set ${key}=${value}`);
-      }
       logger10.success("Local AI plugin configuration validated and initialized");
     } catch (error) {
       logger10.error("Plugin initialization failed:", {