@elizaos/plugin-local-ai 1.0.0 → 1.0.2

package/dist/index.js

@@ -3,10 +3,7 @@ import fs5 from "fs";
 import os3 from "os";
 import path5 from "path";
 import { Readable as Readable2 } from "stream";
-import {
-  ModelType,
-  logger as logger8
-} from "@elizaos/core";
+import { ModelType, logger as logger8 } from "@elizaos/core";
 import {
   LlamaChatSession,
   getLlama
@@ -253,10 +250,7 @@ var DownloadManager = class _DownloadManager {
             reject(new Error(`Failed to download: ${response.statusCode}`));
             return;
           }
-          const totalSize = Number.parseInt(
-            response.headers["content-length"] || "0",
-            10
-          );
+          const totalSize = Number.parseInt(response.headers["content-length"] || "0", 10);
           let downloadedSize = 0;
           let lastLoggedPercent = 0;
           const barLength = 30;
@@ -267,13 +261,9 @@ var DownloadManager = class _DownloadManager {
             downloadedSize += chunk.length;
             const percent = Math.round(downloadedSize / totalSize * 100);
             if (percent >= lastLoggedPercent + 5) {
-              const filledLength = Math.floor(
-                downloadedSize / totalSize * barLength
-              );
+              const filledLength = Math.floor(downloadedSize / totalSize * barLength);
               const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger2.info(
-                `Downloading ${fileName}: ${progressBar} ${percent}%`
-              );
+              logger2.info(`Downloading ${fileName}: ${progressBar} ${percent}%`);
               lastLoggedPercent = percent;
             }
           });
@@ -288,24 +278,18 @@ var DownloadManager = class _DownloadManager {
                   fs.mkdirSync(destDir, { recursive: true });
                 }
                 if (!fs.existsSync(tempPath)) {
-                  reject(
-                    new Error(`Temporary file ${tempPath} does not exist`)
-                  );
+                  reject(new Error(`Temporary file ${tempPath} does not exist`));
                   return;
                 }
                 if (fs.existsSync(destPath)) {
                   try {
                     const backupPath = `${destPath}.bak`;
                     fs.renameSync(destPath, backupPath);
-                    logger2.info(
-                      `Created backup of existing file: ${backupPath}`
-                    );
+                    logger2.info(`Created backup of existing file: ${backupPath}`);
                     fs.renameSync(tempPath, destPath);
                     if (fs.existsSync(backupPath)) {
                       fs.unlinkSync(backupPath);
-                      logger2.info(
-                        `Removed backup file after successful update: ${backupPath}`
-                      );
+                      logger2.info(`Removed backup file after successful update: ${backupPath}`);
                     }
                   } catch (moveErr) {
                     logger2.error(
@@ -315,9 +299,7 @@ var DownloadManager = class _DownloadManager {
                     if (fs.existsSync(backupPath)) {
                       try {
                         fs.renameSync(backupPath, destPath);
-                        logger2.info(
-                          `Restored from backup after failed update: ${backupPath}`
-                        );
+                        logger2.info(`Restored from backup after failed update: ${backupPath}`);
                       } catch (restoreErr) {
                         logger2.error(
                           `Failed to restore from backup: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`
@@ -339,9 +321,7 @@ var DownloadManager = class _DownloadManager {
                 } else {
                   fs.renameSync(tempPath, destPath);
                 }
-                logger2.success(
-                  `Download of ${fileName} completed successfully`
-                );
+                logger2.success(`Download of ${fileName} completed successfully`);
                 this.activeDownloads.delete(destPath);
                 resolve();
               } catch (err) {
@@ -363,9 +343,7 @@ var DownloadManager = class _DownloadManager {
             });
           });
           file.on("error", (err) => {
-            logger2.error(
-              `File write error: ${err instanceof Error ? err.message : String(err)}`
-            );
+            logger2.error(`File write error: ${err instanceof Error ? err.message : String(err)}`);
             file.close(() => {
               if (fs.existsSync(tempPath)) {
                 try {
@@ -383,9 +361,7 @@ var DownloadManager = class _DownloadManager {
         }
       );
       request.on("error", (err) => {
-        logger2.error(
-          `Request error: ${err instanceof Error ? err.message : String(err)}`
-        );
+        logger2.error(`Request error: ${err instanceof Error ? err.message : String(err)}`);
         if (fs.existsSync(tempPath)) {
           try {
             fs.unlinkSync(tempPath);
@@ -424,9 +400,7 @@ var DownloadManager = class _DownloadManager {
    */
   async downloadFile(url, destPath) {
     if (this.activeDownloads.has(destPath)) {
-      logger2.info(
-        `Download for ${destPath} already in progress, waiting for it to complete...`
-      );
+      logger2.info(`Download for ${destPath} already in progress, waiting for it to complete...`);
       const existingDownload = this.activeDownloads.get(destPath);
       if (existingDownload) {
         return existingDownload;
@@ -665,9 +639,7 @@ var PlatformManager = class _PlatformManager {
           isAppleSilicon: true
         };
       }
-      const { stdout: gpuInfo } = await execAsync(
-        "system_profiler SPDisplaysDataType"
-      );
+      const { stdout: gpuInfo } = await execAsync("system_profiler SPDisplaysDataType");
       return {
         name: gpuInfo.split("Chipset Model:")[1]?.split("\n")[0]?.trim() || "Unknown GPU",
         type: "metal",
@@ -689,9 +661,7 @@ var PlatformManager = class _PlatformManager {
    */
   async detectWindowsGPU() {
     try {
-      const { stdout } = await execAsync(
-        "wmic path win32_VideoController get name"
-      );
+      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(
@@ -885,9 +855,7 @@ var getPlatformManager = () => {
 
 // src/utils/tokenizerManager.ts
 import { logger as logger4 } from "@elizaos/core";
-import {
-  AutoTokenizer
-} from "@huggingface/transformers";
+import { AutoTokenizer } from "@huggingface/transformers";
 var TokenizerManager = class _TokenizerManager {
   static instance = null;
   tokenizers;
@@ -937,18 +905,13 @@ var TokenizerManager = class _TokenizerManager {
         logger4.info("Using cached tokenizer:", { key: tokenizerKey });
         const cachedTokenizer = this.tokenizers.get(tokenizerKey);
         if (!cachedTokenizer) {
-          throw new Error(
-            `Tokenizer ${tokenizerKey} exists in map but returned undefined`
-          );
+          throw new Error(`Tokenizer ${tokenizerKey} exists in map but returned undefined`);
         }
         return cachedTokenizer;
       }
       const fs6 = await import("fs");
       if (!fs6.existsSync(this.modelsDir)) {
-        logger4.warn(
-          "Models directory does not exist, creating it:",
-          this.modelsDir
-        );
+        logger4.warn("Models directory does not exist, creating it:", this.modelsDir);
         fs6.mkdirSync(this.modelsDir, { recursive: true });
       }
       logger4.info(
@@ -956,13 +919,10 @@ var TokenizerManager = class _TokenizerManager {
         this.modelsDir
       );
       try {
-        const tokenizer = await AutoTokenizer.from_pretrained(
-          modelConfig.tokenizer.name,
-          {
-            cache_dir: this.modelsDir,
-            local_files_only: false
-          }
-        );
+        const tokenizer = await AutoTokenizer.from_pretrained(modelConfig.tokenizer.name, {
+          cache_dir: this.modelsDir,
+          local_files_only: false
+        });
         this.tokenizers.set(tokenizerKey, tokenizer);
         logger4.success("Tokenizer loaded successfully:", { key: tokenizerKey });
         return tokenizer;
@@ -974,13 +934,10 @@ var TokenizerManager = class _TokenizerManager {
           modelsDir: this.modelsDir
         });
         logger4.info("Retrying tokenizer loading...");
-        const tokenizer = await AutoTokenizer.from_pretrained(
-          modelConfig.tokenizer.name,
-          {
-            cache_dir: this.modelsDir,
-            local_files_only: false
-          }
-        );
+        const tokenizer = await AutoTokenizer.from_pretrained(modelConfig.tokenizer.name, {
+          cache_dir: this.modelsDir,
+          local_files_only: false
+        });
         this.tokenizers.set(tokenizerKey, tokenizer);
         logger4.success("Tokenizer loaded successfully on retry:", {
           key: tokenizerKey
@@ -1078,8 +1035,15 @@ import fs2 from "fs";
 import path2 from "path";
 import { promisify as promisify2 } from "util";
 import { logger as logger5 } from "@elizaos/core";
-import { nodewhisper } from "nodejs-whisper";
 var execAsync2 = promisify2(exec2);
+var whisperModule = null;
+async function getWhisper() {
+  if (!whisperModule) {
+    const module = await import("whisper-node");
+    whisperModule = module.whisper;
+  }
+  return whisperModule;
+}
 var TranscribeManager = class _TranscribeManager {
   static instance = null;
   cacheDir;
@@ -1204,9 +1168,7 @@ var TranscribeManager = class _TranscribeManager {
    */
   async checkFFmpegAvailability() {
     try {
-      const { stdout, stderr } = await execAsync2(
-        "which ffmpeg || where ffmpeg"
-      );
+      const { stdout, stderr } = await execAsync2("which ffmpeg || where ffmpeg");
       this.ffmpegPath = stdout.trim();
       this.ffmpegAvailable = true;
       logger5.info("FFmpeg found at:", {
@@ -1234,9 +1196,7 @@ var TranscribeManager = class _TranscribeManager {
       const { stdout } = await execAsync2("ffmpeg -codecs");
       const hasRequiredCodecs = stdout.includes("pcm_s16le") && stdout.includes("wav");
       if (!hasRequiredCodecs) {
-        throw new Error(
-          "FFmpeg installation missing required codecs (pcm_s16le, wav)"
-        );
+        throw new Error("FFmpeg installation missing required codecs (pcm_s16le, wav)");
       }
     } catch (error) {
       logger5.error("FFmpeg capabilities verification failed:", {
@@ -1250,20 +1210,17 @@ var TranscribeManager = class _TranscribeManager {
    * Logs instructions on how to install FFmpeg if it is not properly installed.
    */
   logFFmpegInstallInstructions() {
-    logger5.warn(
-      "FFmpeg is required but not properly installed. Please install FFmpeg:",
-      {
-        instructions: {
-          mac: "brew install ffmpeg",
-          ubuntu: "sudo apt-get install ffmpeg",
-          windows: "choco install ffmpeg",
-          manual: "Download from https://ffmpeg.org/download.html"
-        },
-        requiredVersion: "4.0 or later",
-        requiredCodecs: ["pcm_s16le", "wav"],
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    );
+    logger5.warn("FFmpeg is required but not properly installed. Please install FFmpeg:", {
+      instructions: {
+        mac: "brew install ffmpeg",
+        ubuntu: "sudo apt-get install ffmpeg",
+        windows: "choco install ffmpeg",
+        manual: "Download from https://ffmpeg.org/download.html"
+      },
+      requiredVersion: "4.0 or later",
+      requiredCodecs: ["pcm_s16le", "wav"],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   /**
    * Gets the singleton instance of TranscribeManager, creates a new instance if it doesn't exist.
@@ -1341,17 +1298,29 @@ var TranscribeManager = class _TranscribeManager {
    */
   async preprocessAudio(audioBuffer) {
     if (!this.ffmpegAvailable) {
-      throw new Error(
-        "FFmpeg is not installed. Please install FFmpeg to use audio transcription."
-      );
+      throw new Error("FFmpeg is not installed. Please install FFmpeg to use audio transcription.");
     }
     try {
-      const tempInputFile = path2.join(
-        this.cacheDir,
-        `temp_input_${Date.now()}`
-      );
+      const isWav = audioBuffer.length > 4 && audioBuffer.toString("ascii", 0, 4) === "RIFF" && audioBuffer.length > 12 && audioBuffer.toString("ascii", 8, 12) === "WAVE";
+      const extension = isWav ? ".wav" : "";
+      const tempInputFile = path2.join(this.cacheDir, `temp_input_${Date.now()}${extension}`);
       const tempWavFile = path2.join(this.cacheDir, `temp_${Date.now()}.wav`);
       fs2.writeFileSync(tempInputFile, audioBuffer);
+      if (isWav) {
+        try {
+          const { stdout } = await execAsync2(
+            `ffprobe -v error -show_entries stream=sample_rate,channels,bits_per_raw_sample -of json "${tempInputFile}"`
+          );
+          const probeResult = JSON.parse(stdout);
+          const stream = probeResult.streams?.[0];
+          if (stream?.sample_rate === "16000" && stream?.channels === 1 && (stream?.bits_per_raw_sample === 16 || stream?.bits_per_raw_sample === void 0)) {
+            fs2.renameSync(tempInputFile, tempWavFile);
+            return tempWavFile;
+          }
+        } catch (probeError) {
+          logger5.debug("FFprobe failed, continuing with conversion:", probeError);
+        }
+      }
       await this.convertToWav(tempInputFile, tempWavFile);
       if (fs2.existsSync(tempInputFile)) {
         fs2.unlinkSync(tempInputFile);
@@ -1386,36 +1355,46 @@ var TranscribeManager = class _TranscribeManager {
     try {
       const wavFile = await this.preprocessAudio(audioBuffer);
       logger5.info("Starting transcription with whisper...");
-      const originalStdoutWrite = process.stdout.write;
-      const originalStderrWrite = process.stderr.write;
-      const noopWrite = () => true;
-      process.stdout.write = noopWrite;
-      process.stderr.write = noopWrite;
-      let output;
+      let segments;
       try {
-        output = await nodewhisper(wavFile, {
-          modelName: "base.en",
-          autoDownloadModelName: "base.en",
-          verbose: false,
+        const whisper = await getWhisper();
+        segments = await whisper(wavFile, {
+          modelName: "tiny",
+          modelPath: path2.join(this.cacheDir, "models"),
+          // Specify where to store models
           whisperOptions: {
-            outputInText: true,
-            language: "en"
+            language: "en",
+            word_timestamps: false
+            // We don't need word-level timestamps
           }
         });
-      } finally {
-        process.stdout.write = originalStdoutWrite;
-        process.stderr.write = originalStderrWrite;
+      } catch (whisperError) {
+        const errorMessage = whisperError instanceof Error ? whisperError.message : String(whisperError);
+        if (errorMessage.includes("not found") || errorMessage.includes("download")) {
+          logger5.error("Whisper model not found. Please run: npx whisper-node download");
+          throw new Error(
+            "Whisper model not found. Please install it with: npx whisper-node download"
+          );
+        }
+        logger5.error("Whisper transcription error:", whisperError);
+        throw whisperError;
       }
       if (fs2.existsSync(wavFile)) {
         fs2.unlinkSync(wavFile);
         logger5.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(" ");
+      if (!segments || !Array.isArray(segments)) {
+        logger5.warn("Whisper returned no segments (likely silence or very short audio)");
+        return { text: "" };
+      }
+      if (segments.length === 0) {
+        logger5.warn("No speech detected in audio");
+        return { text: "" };
+      }
+      const cleanText = segments.map((segment) => segment.speech?.trim() || "").filter((text) => text).join(" ");
       logger5.success("Transcription complete:", {
         textLength: cleanText.length,
+        segmentCount: segments.length,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return { text: cleanText };
@@ -1431,12 +1410,45 @@ var TranscribeManager = class _TranscribeManager {
 };
 
 // src/utils/ttsManager.ts
+import { logger as logger6 } from "@elizaos/core";
+import { pipeline } from "@huggingface/transformers";
 import fs3 from "fs";
 import path3 from "path";
-import { Readable } from "stream";
-import { logger as logger6, prependWavHeader } from "@elizaos/core";
-import { pipeline } from "@huggingface/transformers";
 import { fetch as fetch2 } from "undici";
+import { PassThrough, Readable } from "stream";
+function getWavHeader(audioLength, sampleRate, channelCount = 1, bitsPerSample = 16) {
+  const wavHeader = Buffer.alloc(44);
+  wavHeader.write("RIFF", 0);
+  wavHeader.writeUInt32LE(36 + audioLength, 4);
+  wavHeader.write("WAVE", 8);
+  wavHeader.write("fmt ", 12);
+  wavHeader.writeUInt32LE(16, 16);
+  wavHeader.writeUInt16LE(1, 20);
+  wavHeader.writeUInt16LE(channelCount, 22);
+  wavHeader.writeUInt32LE(sampleRate, 24);
+  wavHeader.writeUInt32LE(sampleRate * bitsPerSample * channelCount / 8, 28);
+  wavHeader.writeUInt16LE(bitsPerSample * channelCount / 8, 32);
+  wavHeader.writeUInt16LE(bitsPerSample, 34);
+  wavHeader.write("data", 36);
+  wavHeader.writeUInt32LE(audioLength, 40);
+  return wavHeader;
+}
+function prependWavHeader(readable, audioLength, sampleRate, channelCount = 1, bitsPerSample = 16) {
+  const wavHeader = getWavHeader(audioLength, sampleRate, channelCount, bitsPerSample);
+  let pushedHeader = false;
+  const passThrough = new PassThrough();
+  readable.on("data", (data) => {
+    if (!pushedHeader) {
+      passThrough.push(wavHeader);
+      pushedHeader = true;
+    }
+    passThrough.push(data);
+  });
+  readable.on("end", () => {
+    passThrough.end();
+  });
+  return passThrough;
+}
 var TTSManager = class _TTSManager {
   static instance = null;
   cacheDir;
@@ -1463,9 +1475,7 @@ var TTSManager = class _TTSManager {
   }
   async initialize() {
     if (this.initializingPromise) {
-      logger6.debug(
-        "TTS initialization already in progress, awaiting existing promise."
-      );
+      logger6.debug("TTS initialization already in progress, awaiting existing promise.");
       return this.initializingPromise;
     }
     if (this.initialized) {
@@ -1477,21 +1487,15 @@ var TTSManager = class _TTSManager {
         logger6.info("Initializing TTS with Transformers.js backend...");
         const ttsModelSpec = MODEL_SPECS.tts.default;
         if (!ttsModelSpec) {
-          throw new Error(
-            "Default TTS model specification not found in MODEL_SPECS."
-          );
+          throw new Error("Default TTS model specification not found in MODEL_SPECS.");
         }
         const modelName = ttsModelSpec.modelId;
         const speakerEmbeddingUrl = ttsModelSpec.defaultSpeakerEmbeddingUrl;
         logger6.info(`Loading TTS pipeline for model: ${modelName}`);
         this.synthesizer = await pipeline("text-to-audio", modelName);
-        logger6.success(
-          `TTS pipeline loaded successfully for model: ${modelName}`
-        );
+        logger6.success(`TTS pipeline loaded successfully for model: ${modelName}`);
         if (speakerEmbeddingUrl) {
-          const embeddingFilename = path3.basename(
-            new URL(speakerEmbeddingUrl).pathname
-          );
+          const embeddingFilename = path3.basename(new URL(speakerEmbeddingUrl).pathname);
           const embeddingPath = path3.join(this.cacheDir, embeddingFilename);
           if (fs3.existsSync(embeddingPath)) {
             logger6.info("Loading default speaker embedding from cache...");
@@ -1503,14 +1507,10 @@ var TTSManager = class _TTSManager {
             );
             logger6.success("Default speaker embedding loaded from cache.");
           } else {
-            logger6.info(
-              `Downloading default speaker embedding from: ${speakerEmbeddingUrl}`
-            );
+            logger6.info(`Downloading default speaker embedding from: ${speakerEmbeddingUrl}`);
             const response = await fetch2(speakerEmbeddingUrl);
             if (!response.ok) {
-              throw new Error(
-                `Failed to download speaker embedding: ${response.statusText}`
-              );
+              throw new Error(`Failed to download speaker embedding: ${response.statusText}`);
             }
             const buffer = await response.arrayBuffer();
             this.defaultSpeakerEmbedding = new Float32Array(buffer);
@@ -1539,9 +1539,7 @@ var TTSManager = class _TTSManager {
         throw error;
       } finally {
         this.initializingPromise = null;
-        logger6.debug(
-          "TTS initializingPromise cleared after completion/failure."
-        );
+        logger6.debug("TTS initializingPromise cleared after completion/failure.");
       }
     })();
     return this.initializingPromise;
@@ -1650,10 +1648,7 @@ var VisionManager = class _VisionManager {
     this.modelsDir = path4.join(path4.dirname(cacheDir), "models", "vision");
     this.cacheDir = cacheDir;
     this.ensureModelsDirExists();
-    this.downloadManager = DownloadManager.getInstance(
-      this.cacheDir,
-      this.modelsDir
-    );
+    this.downloadManager = DownloadManager.getInstance(this.cacheDir, this.modelsDir);
     this.platformConfig = this.getPlatformConfig();
     logger7.debug("VisionManager initialized");
   }
@@ -1717,11 +1712,7 @@ var VisionManager = class _VisionManager {
    * @returns {boolean} - Returns true if cache exists, otherwise returns false.
    */
   checkCacheExists(modelId, type) {
-    const modelPath = path4.join(
-      this.modelsDir,
-      modelId.replace("/", "--"),
-      type
-    );
+    const modelPath = path4.join(this.modelsDir, modelId.replace("/", "--"), type);
     if (existsSync(modelPath)) {
       logger7.info(`${type} found at: ${modelPath}`);
       return true;
@@ -1759,9 +1750,7 @@ var VisionManager = class _VisionManager {
    * @returns {object} The model configuration object containing device, dtype, and cache_dir.
    */
   getModelConfig(componentName) {
-    const component = this.modelComponents.find(
-      (c) => c.name === componentName
-    );
+    const component = this.modelComponents.find((c) => c.name === componentName);
     return {
       device: this.platformConfig.device,
       dtype: component?.dtype || "fp32",
@@ -1777,9 +1766,7 @@ var VisionManager = class _VisionManager {
   async initialize() {
     try {
       if (this.initialized) {
-        logger7.info(
-          "Vision model already initialized, skipping initialization"
-        );
+        logger7.info("Vision model already initialized, skipping initialization");
         return;
       }
       logger7.info("Starting vision model initialization...");
@@ -1795,32 +1782,25 @@ var VisionManager = class _VisionManager {
       try {
         let lastProgress = -1;
         const modelCached = this.checkCacheExists(modelSpec.modelId, "model");
-        const model = await Florence2ForConditionalGeneration.from_pretrained(
-          modelSpec.modelId,
-          {
-            device: "cpu",
-            cache_dir: this.modelsDir,
-            local_files_only: modelCached,
-            revision: "main",
-            progress_callback: (progressInfo) => {
-              if (modelCached || this.modelDownloaded) return;
-              const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
-              const currentProgress = Math.round(progress * 100);
-              if (currentProgress > lastProgress + 9 || currentProgress === 100) {
-                lastProgress = currentProgress;
-                const barLength = 30;
-                const filledLength = Math.floor(
-                  currentProgress / 100 * barLength
-                );
-                const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-                logger7.info(
-                  `Downloading vision model: ${progressBar} ${currentProgress}%`
-                );
-                if (currentProgress === 100) this.modelDownloaded = true;
-              }
+        const model = await Florence2ForConditionalGeneration.from_pretrained(modelSpec.modelId, {
+          device: "cpu",
+          cache_dir: this.modelsDir,
+          local_files_only: modelCached,
+          revision: "main",
+          progress_callback: (progressInfo) => {
+            if (modelCached || this.modelDownloaded) return;
+            const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
+            const currentProgress = Math.round(progress * 100);
+            if (currentProgress > lastProgress + 9 || currentProgress === 100) {
+              lastProgress = currentProgress;
+              const barLength = 30;
+              const filledLength = Math.floor(currentProgress / 100 * barLength);
+              const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
+              logger7.info(`Downloading vision model: ${progressBar} ${currentProgress}%`);
+              if (currentProgress === 100) this.modelDownloaded = true;
             }
           }
-        );
+        });
         this.model = model;
         logger7.success("Florence2 model loaded successfully");
       } catch (error) {
@@ -1833,35 +1813,25 @@ var VisionManager = class _VisionManager {
       }
       logger7.info("Loading vision tokenizer...");
       try {
-        const tokenizerCached = this.checkCacheExists(
-          modelSpec.modelId,
-          "tokenizer"
-        );
+        const tokenizerCached = this.checkCacheExists(modelSpec.modelId, "tokenizer");
         let tokenizerProgress = -1;
-        this.tokenizer = await AutoTokenizer2.from_pretrained(
-          modelSpec.modelId,
-          {
-            cache_dir: this.modelsDir,
-            local_files_only: tokenizerCached,
-            progress_callback: (progressInfo) => {
-              if (tokenizerCached || this.tokenizerDownloaded) return;
-              const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
-              const currentProgress = Math.round(progress * 100);
-              if (currentProgress !== tokenizerProgress) {
-                tokenizerProgress = currentProgress;
-                const barLength = 30;
-                const filledLength = Math.floor(
-                  currentProgress / 100 * barLength
-                );
-                const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-                logger7.info(
-                  `Downloading vision tokenizer: ${progressBar} ${currentProgress}%`
-                );
-                if (currentProgress === 100) this.tokenizerDownloaded = true;
-              }
+        this.tokenizer = await AutoTokenizer2.from_pretrained(modelSpec.modelId, {
+          cache_dir: this.modelsDir,
+          local_files_only: tokenizerCached,
+          progress_callback: (progressInfo) => {
+            if (tokenizerCached || this.tokenizerDownloaded) return;
+            const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
+            const currentProgress = Math.round(progress * 100);
+            if (currentProgress !== tokenizerProgress) {
+              tokenizerProgress = currentProgress;
+              const barLength = 30;
+              const filledLength = Math.floor(currentProgress / 100 * barLength);
+              const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
+              logger7.info(`Downloading vision tokenizer: ${progressBar} ${currentProgress}%`);
+              if (currentProgress === 100) this.tokenizerDownloaded = true;
             }
           }
-        );
+        });
         logger7.success("Vision tokenizer loaded successfully");
       } catch (error) {
         logger7.error("Failed to load tokenizer:", {
@@ -1873,36 +1843,26 @@ var VisionManager = class _VisionManager {
       }
       logger7.info("Loading vision processor...");
       try {
-        const processorCached = this.checkCacheExists(
-          modelSpec.modelId,
-          "processor"
-        );
+        const processorCached = this.checkCacheExists(modelSpec.modelId, "processor");
         let processorProgress = -1;
-        this.processor = await AutoProcessor.from_pretrained(
-          modelSpec.modelId,
-          {
-            device: "cpu",
-            cache_dir: this.modelsDir,
-            local_files_only: processorCached,
-            progress_callback: (progressInfo) => {
-              if (processorCached || this.processorDownloaded) return;
-              const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
-              const currentProgress = Math.round(progress * 100);
-              if (currentProgress !== processorProgress) {
-                processorProgress = currentProgress;
-                const barLength = 30;
-                const filledLength = Math.floor(
-                  currentProgress / 100 * barLength
-                );
-                const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-                logger7.info(
-                  `Downloading vision processor: ${progressBar} ${currentProgress}%`
-                );
-                if (currentProgress === 100) this.processorDownloaded = true;
-              }
+        this.processor = await AutoProcessor.from_pretrained(modelSpec.modelId, {
+          device: "cpu",
+          cache_dir: this.modelsDir,
+          local_files_only: processorCached,
+          progress_callback: (progressInfo) => {
+            if (processorCached || this.processorDownloaded) return;
+            const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
+            const currentProgress = Math.round(progress * 100);
+            if (currentProgress !== processorProgress) {
+              processorProgress = currentProgress;
+              const barLength = 30;
+              const filledLength = Math.floor(currentProgress / 100 * barLength);
+              const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
+              logger7.info(`Downloading vision processor: ${progressBar} ${currentProgress}%`);
+              if (currentProgress === 100) this.processorDownloaded = true;
             }
           }
-        );
+        });
         logger7.success("Vision processor loaded successfully");
       } catch (error) {
         logger7.error("Failed to load vision processor:", {
@@ -2139,14 +2099,8 @@ var LocalAIManager = class _LocalAIManager {
    */
   _postValidateInit() {
     this._setupModelsDir();
-    this.downloadManager = DownloadManager.getInstance(
-      this.cacheDir,
-      this.modelsDir
-    );
-    this.tokenizerManager = TokenizerManager.getInstance(
-      this.cacheDir,
-      this.modelsDir
-    );
+    this.downloadManager = DownloadManager.getInstance(this.cacheDir, this.modelsDir);
+    this.tokenizerManager = TokenizerManager.getInstance(this.cacheDir, this.modelsDir);
     this.visionManager = VisionManager.getInstance(this.cacheDir);
     this.transcribeManager = TranscribeManager.getInstance(this.cacheDir);
     this.ttsManager = TTSManager.getInstance(this.cacheDir);
@@ -2159,10 +2113,7 @@ var LocalAIManager = class _LocalAIManager {
     const modelsDirEnv = this.config?.MODELS_DIR?.trim() || process.env.MODELS_DIR?.trim();
     if (modelsDirEnv) {
       this.modelsDir = path5.resolve(modelsDirEnv);
-      logger8.info(
-        "Using models directory from MODELS_DIR environment variable:",
-        this.modelsDir
-      );
+      logger8.info("Using models directory from MODELS_DIR environment variable:", this.modelsDir);
     } else {
       this.modelsDir = path5.join(os3.homedir(), ".eliza", "models");
       logger8.info(
@@ -2172,10 +2123,7 @@ var LocalAIManager = class _LocalAIManager {
     }
     if (!fs5.existsSync(this.modelsDir)) {
       fs5.mkdirSync(this.modelsDir, { recursive: true });
-      logger8.debug(
-        "Ensured models directory exists (created):",
-        this.modelsDir
-      );
+      logger8.debug("Ensured models directory exists (created):", this.modelsDir);
     } else {
       logger8.debug("Models directory already exists:", this.modelsDir);
     }
@@ -2188,10 +2136,7 @@ var LocalAIManager = class _LocalAIManager {
     const cacheDirEnv = this.config?.CACHE_DIR?.trim() || process.env.CACHE_DIR?.trim();
     if (cacheDirEnv) {
       this.cacheDir = path5.resolve(cacheDirEnv);
-      logger8.info(
-        "Using cache directory from CACHE_DIR environment variable:",
-        this.cacheDir
-      );
+      logger8.info("Using cache directory from CACHE_DIR environment variable:", this.cacheDir);
     } else {
       const cacheDir = path5.join(os3.homedir(), ".eliza", "cache");
       if (!fs5.existsSync(cacheDir)) {
@@ -2238,24 +2183,12 @@ var LocalAIManager = class _LocalAIManager {
         logger8.info("Initializing environment configuration...");
         this.config = await validateConfig();
         this._postValidateInit();
-        this.modelPath = path5.join(
-          this.modelsDir,
-          this.config.LOCAL_SMALL_MODEL
-        );
-        this.mediumModelPath = path5.join(
-          this.modelsDir,
-          this.config.LOCAL_LARGE_MODEL
-        );
-        this.embeddingModelPath = path5.join(
-          this.modelsDir,
-          this.config.LOCAL_EMBEDDING_MODEL
-        );
+        this.modelPath = path5.join(this.modelsDir, this.config.LOCAL_SMALL_MODEL);
+        this.mediumModelPath = path5.join(this.modelsDir, this.config.LOCAL_LARGE_MODEL);
+        this.embeddingModelPath = path5.join(this.modelsDir, this.config.LOCAL_EMBEDDING_MODEL);
         logger8.info("Using small model path:", basename(this.modelPath));
         logger8.info("Using medium model path:", basename(this.mediumModelPath));
-        logger8.info(
-          "Using embedding model path:",
-          basename(this.embeddingModelPath)
-        );
+        logger8.info("Using embedding model path:", basename(this.embeddingModelPath));
         logger8.info("Environment configuration validated and model paths set");
         this.environmentInitialized = true;
         logger8.success("Environment initialization complete");
@@ -2293,10 +2226,7 @@ var LocalAIManager = class _LocalAIManager {
       modelPathToDownload = modelType === ModelType.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
     }
     try {
-      return await this.downloadManager.downloadModel(
-        modelSpec,
-        modelPathToDownload
-      );
+      return await this.downloadManager.downloadModel(modelSpec, modelPathToDownload);
     } catch (error) {
       logger8.error("Model download failed:", {
         error: error instanceof Error ? error.message : String(error),
@@ -2351,10 +2281,7 @@ var LocalAIManager = class _LocalAIManager {
       logger8.info("Initializing embedding model...");
       logger8.info("Models directory:", this.modelsDir);
       if (!fs5.existsSync(this.modelsDir)) {
-        logger8.warn(
-          "Models directory does not exist, creating it:",
-          this.modelsDir
-        );
+        logger8.warn("Models directory does not exist, creating it:", this.modelsDir);
         fs5.mkdirSync(this.modelsDir, { recursive: true });
       }
       await this.downloadModel(ModelType.TEXT_EMBEDDING);
@@ -2508,10 +2435,7 @@ var LocalAIManager = class _LocalAIManager {
         runtime: !!params.runtime,
         stopSequences: params.stopSequences
       });
-      const tokens = await this.tokenizerManager.encode(
-        params.prompt,
-        this.activeModelConfig
-      );
+      const tokens = await this.tokenizerManager.encode(params.prompt, this.activeModelConfig);
       logger8.info("Input tokens:", { count: tokens.length });
       const systemMessage = "You are a helpful AI assistant. Respond to the current request only.";
       await this.chatSession.prompt(systemMessage, {
@@ -2701,9 +2625,7 @@ var LocalAIManager = class _LocalAIManager {
         try {
           await this.initializeEnvironment();
           if (!this.transcribeManager) {
-            this.transcribeManager = TranscribeManager.getInstance(
-              this.cacheDir
-            );
+            this.transcribeManager = TranscribeManager.getInstance(this.cacheDir);
           }
           const ffmpegReady = await this.transcribeManager.ensureFFmpeg();
           if (!ffmpegReady) {
@@ -2715,9 +2637,7 @@ var LocalAIManager = class _LocalAIManager {
             );
           }
           this.transcriptionInitialized = true;
-          logger8.info(
-            "Transcription prerequisites (FFmpeg) checked and ready."
-          );
+          logger8.info("Transcription prerequisites (FFmpeg) checked and ready.");
           logger8.info("Transcription model initialized successfully");
         } catch (error) {
           logger8.error("Failed to initialize transcription model:", error);
@@ -2800,9 +2720,7 @@ var localAiPlugin = {
       const text = params?.text;
       try {
         if (!text) {
-          logger8.debug(
-            "Null or empty text input for embedding, returning zero vector"
-          );
+          logger8.debug("Null or empty text input for embedding, returning zero vector");
           return new Array(384).fill(0);
         }
         return await localAIManager.generateEmbedding(text);
@@ -2854,13 +2772,8 @@ var localAiPlugin = {
           try {
             jsonObject = JSON.parse(extractedJsonText);
           } catch (parseError) {
-            logger8.debug(
-              "Initial JSON parse failed, attempting to fix common issues"
-            );
-            const fixedJson = extractedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(
-              /"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g,
-              '"$1$2"'
-            ).replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
+            logger8.debug("Initial JSON parse failed, attempting to fix common issues");
+            const fixedJson = extractedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(/"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g, '"$1$2"').replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
             try {
               jsonObject = JSON.parse(fixedJson);
             } catch (finalError) {
@@ -2932,13 +2845,8 @@ var localAiPlugin = {
           try {
             jsonObject = JSON.parse(cleanedJsonText);
           } catch (parseError) {
-            logger8.debug(
-              "Initial JSON parse failed, attempting to fix common issues"
-            );
-            const fixedJson = cleanedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(
-              /"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g,
-              '"$1$2"'
-            ).replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
+            logger8.debug("Initial JSON parse failed, attempting to fix common issues");
+            const fixedJson = cleanedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(/"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g, '"$1$2"').replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
             try {
               jsonObject = JSON.parse(fixedJson);
             } catch (finalError) {
@@ -3093,16 +3001,10 @@ var localAiPlugin = {
           fn: async (runtime) => {
             try {
               logger8.info("Starting TEXT_EMBEDDING test");
-              const embedding = await runtime.useModel(
-                ModelType.TEXT_EMBEDDING,
-                {
-                  text: "This is a test of the text embedding model."
-                }
-              );
-              logger8.info(
-                "Embedding generated with dimensions:",
-                embedding.length
-              );
+              const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+                text: "This is a test of the text embedding model."
+              });
+              logger8.info("Embedding generated with dimensions:", embedding.length);
               if (!Array.isArray(embedding)) {
                 throw new Error("Embedding is not an array");
               }
@@ -3112,10 +3014,7 @@ var localAiPlugin = {
               if (embedding.some((val) => typeof val !== "number")) {
                 throw new Error("Embedding contains non-numeric values");
               }
-              const nullEmbedding = await runtime.useModel(
-                ModelType.TEXT_EMBEDDING,
-                null
-              );
+              const nullEmbedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, null);
               if (!Array.isArray(nullEmbedding) || nullEmbedding.some((val) => val !== 0)) {
                 throw new Error("Null input did not return zero vector");
               }
@@ -3135,10 +3034,7 @@ var localAiPlugin = {
             try {
               logger8.info("Starting TEXT_TOKENIZER_ENCODE test");
               const text = "Hello tokenizer test!";
-              const tokens = await runtime.useModel(
-                ModelType.TEXT_TOKENIZER_ENCODE,
-                { text }
-              );
+              const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, { text });
               logger8.info("Encoded tokens:", { count: tokens.length });
               if (!Array.isArray(tokens)) {
                 throw new Error("Tokens output is not an array");
@@ -3149,9 +3045,7 @@ var localAiPlugin = {
               if (tokens.some((token) => !Number.isInteger(token))) {
                 throw new Error("Tokens contain non-integer values");
               }
-              logger8.success(
-                "TEXT_TOKENIZER_ENCODE test completed successfully"
-              );
+              logger8.success("TEXT_TOKENIZER_ENCODE test completed successfully");
             } catch (error) {
               logger8.error("TEXT_TOKENIZER_ENCODE test failed:", {
                 error: error instanceof Error ? error.message : String(error),
@@ -3167,18 +3061,12 @@ var localAiPlugin = {
             try {
               logger8.info("Starting TEXT_TOKENIZER_DECODE test");
               const originalText = "Hello tokenizer test!";
-              const tokens = await runtime.useModel(
-                ModelType.TEXT_TOKENIZER_ENCODE,
-                {
-                  text: originalText
-                }
-              );
-              const decodedText = await runtime.useModel(
-                ModelType.TEXT_TOKENIZER_DECODE,
-                {
-                  tokens
-                }
-              );
+              const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, {
+                text: originalText
+              });
+              const decodedText = await runtime.useModel(ModelType.TEXT_TOKENIZER_DECODE, {
+                tokens
+              });
               logger8.info("Round trip tokenization:", {
                 original: originalText,
                 decoded: decodedText
@@ -3186,9 +3074,7 @@ var localAiPlugin = {
               if (typeof decodedText !== "string") {
                 throw new Error("Decoded output is not a string");
               }
-              logger8.success(
-                "TEXT_TOKENIZER_DECODE test completed successfully"
-              );
+              logger8.success("TEXT_TOKENIZER_DECODE test completed successfully");
             } catch (error) {
               logger8.error("TEXT_TOKENIZER_DECODE test failed:", {
                 error: error instanceof Error ? error.message : String(error),
@@ -3203,11 +3089,8 @@ var localAiPlugin = {
           fn: async (runtime) => {
             try {
               logger8.info("Starting IMAGE_DESCRIPTION test");
-              const imageUrl = "https://raw.githubusercontent.com/microsoft/FLAML/main/website/static/img/flaml.png";
-              const result = await runtime.useModel(
-                ModelType.IMAGE_DESCRIPTION,
-                imageUrl
-              );
+              const imageUrl = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/320px-Cat03.jpg";
+              const result = await runtime.useModel(ModelType.IMAGE_DESCRIPTION, imageUrl);
               logger8.info("Image description result:", result);
               if (!result || typeof result !== "object") {
                 throw new Error("Invalid response format");
@@ -3233,37 +3116,37 @@ var localAiPlugin = {
           fn: async (runtime) => {
             try {
               logger8.info("Starting TRANSCRIPTION test");
-              const audioData = new Uint8Array([
-                82,
-                73,
-                70,
-                70,
-                // "RIFF"
-                36,
-                0,
-                0,
-                0,
-                // Chunk size
-                87,
-                65,
-                86,
-                69,
-                // "WAVE"
-                102,
-                109,
-                116,
-                32
-                // "fmt "
-              ]);
-              const audioBuffer = Buffer.from(audioData);
-              const transcription = await runtime.useModel(
-                ModelType.TRANSCRIPTION,
-                audioBuffer
-              );
+              const channels = 1;
+              const sampleRate = 16e3;
+              const bitsPerSample = 16;
+              const duration = 0.5;
+              const numSamples = Math.floor(sampleRate * duration);
+              const dataSize = numSamples * channels * (bitsPerSample / 8);
+              const buffer = Buffer.alloc(44 + dataSize);
+              buffer.write("RIFF", 0);
+              buffer.writeUInt32LE(36 + dataSize, 4);
+              buffer.write("WAVE", 8);
+              buffer.write("fmt ", 12);
+              buffer.writeUInt32LE(16, 16);
+              buffer.writeUInt16LE(1, 20);
+              buffer.writeUInt16LE(channels, 22);
+              buffer.writeUInt32LE(sampleRate, 24);
+              buffer.writeUInt32LE(sampleRate * channels * (bitsPerSample / 8), 28);
+              buffer.writeUInt16LE(channels * (bitsPerSample / 8), 32);
+              buffer.writeUInt16LE(bitsPerSample, 34);
+              buffer.write("data", 36);
+              buffer.writeUInt32LE(dataSize, 40);
+              const frequency = 440;
+              for (let i = 0; i < numSamples; i++) {
+                const sample = Math.sin(2 * Math.PI * frequency * i / sampleRate) * 0.1 * 32767;
+                buffer.writeInt16LE(Math.floor(sample), 44 + i * 2);
+              }
+              const transcription = await runtime.useModel(ModelType.TRANSCRIPTION, buffer);
               logger8.info("Transcription result:", transcription);
               if (typeof transcription !== "string") {
                 throw new Error("Transcription result is not a string");
               }
+              logger8.info("Transcription completed (may be empty for non-speech audio)");
               logger8.success("TRANSCRIPTION test completed successfully");
             } catch (error) {
               logger8.error("TRANSCRIPTION test failed:", {
@@ -3280,10 +3163,7 @@ var localAiPlugin = {
             try {
               logger8.info("Starting TEXT_TO_SPEECH test");
               const testText = "This is a test of the text to speech system.";
-              const audioStream = await runtime.useModel(
-                ModelType.TEXT_TO_SPEECH,
-                testText
-              );
+              const audioStream = await runtime.useModel(ModelType.TEXT_TO_SPEECH, testText);
               if (!(audioStream instanceof Readable2)) {
                 throw new Error("TTS output is not a readable stream");
               }