@elizaos/plugin-local-ai 1.0.0-beta.48 → 1.0.0-beta.49

package/dist/index.js

@@ -3,52 +3,53 @@ import fs5 from "node:fs";
 import os3 from "node:os";
 import path5 from "node:path";
 import { Readable as Readable2 } from "node:stream";
-import { fileURLToPath } from "node:url";
-import { ModelType as ModelType2, logger as logger9 } from "@elizaos/core";
+import { ModelType, logger as logger8 } from "@elizaos/core";
 import {
   LlamaChatSession,
-  getLlama as getLlama2
+  getLlama
 } from "node-llama-cpp";
 
 // src/environment.ts
 import { logger } from "@elizaos/core";
 import { z } from "zod";
+var DEFAULT_SMALL_MODEL = "DeepHermes-3-Llama-3-3B-Preview-q4.gguf";
+var DEFAULT_LARGE_MODEL = "DeepHermes-3-Llama-3-8B-q4.gguf";
+var DEFAULT_EMBEDDING_MODEL = "bge-small-en-v1.5.Q4_K_M.gguf";
 var configSchema = z.object({
-  USE_LOCAL_AI: z.boolean().default(true),
-  USE_STUDIOLM_TEXT_MODELS: z.boolean().default(false),
-  // 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.string().default("BAAI/bge-small-en-v1.5")
+  LOCAL_SMALL_MODEL: z.string().optional().default(DEFAULT_SMALL_MODEL),
+  LOCAL_LARGE_MODEL: z.string().optional().default(DEFAULT_LARGE_MODEL),
+  LOCAL_EMBEDDING_MODEL: z.string().optional().default(DEFAULT_EMBEDDING_MODEL),
+  MODELS_DIR: z.string().optional(),
+  // Path for the models directory
+  CACHE_DIR: z.string().optional(),
+  // Path for the cache directory
+  LOCAL_EMBEDDING_DIMENSIONS: z.string().optional().default("384").transform((val) => parseInt(val, 10))
+  // Transform to number
 });
-function 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
-  });
-  if (!config.USE_LOCAL_AI) {
-    config.USE_LOCAL_AI = true;
-    logger.info("Setting USE_LOCAL_AI to true as it's required");
-  }
-  logger.info("Configuration is valid");
-}
-async function validateConfig(config) {
+function validateConfig() {
   try {
-    const booleanConfig = {
-      USE_LOCAL_AI: true,
-      // Always true
-      USE_STUDIOLM_TEXT_MODELS: config.USE_STUDIOLM_TEXT_MODELS === "true"
-    };
-    validateModelConfig(booleanConfig);
-    const fullConfig = {
-      ...booleanConfig,
-      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 || "BAAI/bge-small-en-v1.5"
+    const configToParse = {
+      // Read model filenames from environment variables or use undefined (so zod defaults apply)
+      LOCAL_SMALL_MODEL: process.env.LOCAL_SMALL_MODEL,
+      LOCAL_LARGE_MODEL: process.env.LOCAL_LARGE_MODEL,
+      LOCAL_EMBEDDING_MODEL: process.env.LOCAL_EMBEDDING_MODEL,
+      MODELS_DIR: process.env.MODELS_DIR,
+      // Read models directory path from env
+      CACHE_DIR: process.env.CACHE_DIR,
+      // Read cache directory path from env
+      LOCAL_EMBEDDING_DIMENSIONS: process.env.LOCAL_EMBEDDING_DIMENSIONS
+      // Read embedding dimensions
     };
-    const validatedConfig = configSchema.parse(fullConfig);
+    logger.debug("Validating configuration for local AI plugin from env:", {
+      LOCAL_SMALL_MODEL: configToParse.LOCAL_SMALL_MODEL,
+      LOCAL_LARGE_MODEL: configToParse.LOCAL_LARGE_MODEL,
+      LOCAL_EMBEDDING_MODEL: configToParse.LOCAL_EMBEDDING_MODEL,
+      MODELS_DIR: configToParse.MODELS_DIR,
+      CACHE_DIR: configToParse.CACHE_DIR,
+      LOCAL_EMBEDDING_DIMENSIONS: configToParse.LOCAL_EMBEDDING_DIMENSIONS
+    });
+    const validatedConfig = configSchema.parse(configToParse);
+    logger.info("Using local AI configuration:", validatedConfig);
     return validatedConfig;
   } catch (error) {
     if (error instanceof z.ZodError) {
@@ -138,78 +139,12 @@ var MODEL_SPECS = {
     ]
   },
   tts: {
-    base: {
-      name: "OuteTTS-0.2-500M-Q8_0.gguf",
-      repo: "OuteAI/OuteTTS-0.2-500M-GGUF",
-      size: "500M",
-      quantization: "Q8_0",
-      speakers: ["male_1", "male_2", "female_1", "female_2"],
-      languages: ["en"],
-      features: ["MULTI_SPEAKER", "VOICE_CLONING", "EMOTION_CONTROL", "SPEED_CONTROL"],
-      maxInputLength: 4096,
-      sampleRate: 24e3,
-      contextSize: 2048,
-      tokenizer: {
-        name: "OuteAI/OuteTTS-0.2-500M",
-        type: "llama"
-      }
-    },
-    medium: {
-      name: "OuteTTS-0.3-1B.gguf",
-      repo: "OuteAI/OuteTTS-0.3-1B-GGUF",
-      size: "1B",
-      quantization: "Q8_0",
-      speakers: ["male_1", "male_2", "male_3", "female_1", "female_2", "female_3"],
-      languages: ["en", "es", "fr", "de", "it"],
-      features: [
-        "MULTI_SPEAKER",
-        "VOICE_CLONING",
-        "EMOTION_CONTROL",
-        "SPEED_CONTROL",
-        "MULTILINGUAL",
-        "ACCENT_CONTROL"
-      ],
-      maxInputLength: 8192,
-      sampleRate: 32e3,
-      contextSize: 4096,
-      tokenizer: {
-        name: "OuteAI/OuteTTS-0.3-1B",
-        type: "llama"
-      }
-    },
-    large: {
-      name: "OuteTTS-0.3-3B.gguf",
-      repo: "OuteAI/OuteTTS-0.3-3B-GGUF",
-      size: "3B",
-      quantization: "Q8_0",
-      speakers: [
-        "male_1",
-        "male_2",
-        "male_3",
-        "male_4",
-        "female_1",
-        "female_2",
-        "female_3",
-        "female_4"
-      ],
-      languages: ["en", "es", "fr", "de", "it", "pt", "nl", "pl", "ru", "ja", "ko", "zh"],
-      features: [
-        "MULTI_SPEAKER",
-        "VOICE_CLONING",
-        "EMOTION_CONTROL",
-        "SPEED_CONTROL",
-        "MULTILINGUAL",
-        "ACCENT_CONTROL",
-        "STYLE_TRANSFER",
-        "PROSODY_CONTROL"
-      ],
-      maxInputLength: 16384,
-      sampleRate: 48e3,
-      contextSize: 8192,
-      tokenizer: {
-        name: "OuteAI/OuteTTS-0.3-3B",
-        type: "llama"
-      }
+    default: {
+      modelId: "Xenova/speecht5_tts",
+      defaultSampleRate: 16e3,
+      // SpeechT5 default
+      // Use the standard embedding URL
+      defaultSpeakerEmbeddingUrl: "https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/speaker_embeddings.bin"
     }
   }
 };
@@ -918,297 +853,8 @@ var getPlatformManager = () => {
   return PlatformManager.getInstance();
 };
 
-// src/utils/studiolmManager.ts
-import { ModelType, logger as logger4 } from "@elizaos/core";
-var StudioLMManager = class _StudioLMManager {
-  static instance = null;
-  serverUrl;
-  initialized = false;
-  availableModels = [];
-  configuredModels = {
-    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";
-    logger4.info("StudioLMManager initialized with configuration:", {
-      serverUrl: this.serverUrl,
-      configuredModels: this.configuredModels,
-      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 fetch(`${this.serverUrl}/v1/models`);
-      if (!response.ok) {
-        throw new Error(`Server responded with status: ${response.status}`);
-      }
-      return true;
-    } catch (error) {
-      logger4.error("LM Studio server check failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        serverUrl: this.serverUrl,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      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 fetch(`${this.serverUrl}/v1/models`);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch models: ${response.status}`);
-      }
-      const data = await response.json();
-      this.availableModels = data.data;
-      logger4.info("LM Studio available models:", {
-        count: this.availableModels.length,
-        models: this.availableModels.map((m) => m.id),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } catch (error) {
-      logger4.error("Failed to fetch LM Studio models:", {
-        error: error instanceof Error ? error.message : String(error),
-        serverUrl: this.serverUrl,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      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 = {
-        model: modelId,
-        messages: [
-          {
-            role: "system",
-            content: "Always answer in rhymes. Today is Thursday"
-          },
-          { role: "user", content: "What day is it today?" }
-        ],
-        temperature: 0.7,
-        max_tokens: -1,
-        stream: false
-      };
-      logger4.info(`Testing model ${modelId}...`);
-      const response = await fetch(`${this.serverUrl}/v1/chat/completions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(testRequest)
-      });
-      if (!response.ok) {
-        throw new Error(`Model test failed with status: ${response.status}`);
-      }
-      const result = await response.json();
-      if (!result.choices?.[0]?.message?.content) {
-        throw new Error("No valid response content received");
-      }
-      logger4.info(`Model ${modelId} test response:`, {
-        content: result.choices[0].message.content,
-        model: result.model,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return true;
-    } catch (error) {
-      logger4.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()
-      });
-      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() {
-    logger4.info("Testing configured text models...");
-    const results = await Promise.all([
-      this.testModel(this.configuredModels.small),
-      this.testModel(this.configuredModels.medium)
-    ]);
-    const [smallWorking, mediumWorking] = results;
-    if (!smallWorking || !mediumWorking) {
-      const failedModels = [];
-      if (!smallWorking) failedModels.push("small");
-      if (!mediumWorking) failedModels.push("medium");
-      logger4.warn("Some models failed the test:", {
-        failedModels,
-        small: this.configuredModels.small,
-        medium: this.configuredModels.medium
-      });
-    } else {
-      logger4.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) {
-        logger4.info("StudioLM already initialized, skipping initialization");
-        return;
-      }
-      logger4.info("Starting StudioLM initialization...");
-      const serverAvailable = await this.checkServerStatus();
-      if (!serverAvailable) {
-        throw new Error("LM Studio server is not available");
-      }
-      await this.fetchAvailableModels();
-      await this.testTextModels();
-      this.initialized = true;
-      logger4.success("StudioLM initialization complete");
-    } catch (error) {
-      logger4.error("StudioLM initialization failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0
-      });
-      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 {
-      logger4.info("StudioLM generateText entry:", {
-        isInitialized,
-        currentInitState: this.initialized,
-        managerInitState: this.isInitialized(),
-        modelType: params.modelType,
-        contextLength: params.prompt?.length,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      if (!this.initialized && !isInitialized) {
-        throw new Error("StudioLM not initialized. Please initialize before generating text.");
-      }
-      const messages = [
-        {
-          role: "system",
-          content: "You are a helpful AI assistant. Respond to the current request only."
-        },
-        { role: "user", content: params.prompt }
-      ];
-      logger4.info("StudioLM preparing request:", {
-        model: params.modelType === ModelType.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
-        messageCount: messages.length,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      logger4.info("Incoming context structure:", {
-        contextLength: params.prompt.length,
-        hasAction: params.prompt.includes("action"),
-        runtime: !!params.runtime,
-        stopSequences: params.stopSequences
-      });
-      const request = {
-        model: params.modelType === ModelType.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
-        messages,
-        temperature: 0.7,
-        max_tokens: 8192,
-        stream: false
-      };
-      const response = await fetch(`${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;
-      logger4.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");
-        responseText = responseText.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-        logger4.info("Think tags removed from response");
-      }
-      logger4.info("StudioLM request completed successfully:", {
-        responseLength: responseText.length,
-        hasThinkTags: responseText.includes("<think>"),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return responseText;
-    } catch (error) {
-      logger4.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 logger5 } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 import { AutoTokenizer } from "@huggingface/transformers";
 var TokenizerManager = class _TokenizerManager {
   static instance = null;
@@ -1248,7 +894,7 @@ var TokenizerManager = class _TokenizerManager {
   async loadTokenizer(modelConfig) {
     try {
       const tokenizerKey = `${modelConfig.tokenizer.type}-${modelConfig.tokenizer.name}`;
-      logger5.info("Loading tokenizer:", {
+      logger4.info("Loading tokenizer:", {
         key: tokenizerKey,
         name: modelConfig.tokenizer.name,
         type: modelConfig.tokenizer.type,
@@ -1256,7 +902,7 @@ var TokenizerManager = class _TokenizerManager {
         cacheDir: this.cacheDir
       });
       if (this.tokenizers.has(tokenizerKey)) {
-        logger5.info("Using cached tokenizer:", { key: tokenizerKey });
+        logger4.info("Using cached tokenizer:", { key: tokenizerKey });
         const cachedTokenizer = this.tokenizers.get(tokenizerKey);
         if (!cachedTokenizer) {
           throw new Error(`Tokenizer ${tokenizerKey} exists in map but returned undefined`);
@@ -1265,10 +911,10 @@ var TokenizerManager = class _TokenizerManager {
       }
       const fs6 = await import("node:fs");
       if (!fs6.existsSync(this.modelsDir)) {
-        logger5.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 });
       }
-      logger5.info(
+      logger4.info(
         "Initializing new tokenizer from HuggingFace with models directory:",
         this.modelsDir
       );
@@ -1278,28 +924,28 @@ var TokenizerManager = class _TokenizerManager {
           local_files_only: false
         });
         this.tokenizers.set(tokenizerKey, tokenizer);
-        logger5.success("Tokenizer loaded successfully:", { key: tokenizerKey });
+        logger4.success("Tokenizer loaded successfully:", { key: tokenizerKey });
         return tokenizer;
       } catch (tokenizeError) {
-        logger5.error("Failed to load tokenizer from HuggingFace:", {
+        logger4.error("Failed to load tokenizer from HuggingFace:", {
           error: tokenizeError instanceof Error ? tokenizeError.message : String(tokenizeError),
           stack: tokenizeError instanceof Error ? tokenizeError.stack : void 0,
           tokenizer: modelConfig.tokenizer.name,
           modelsDir: this.modelsDir
         });
-        logger5.info("Retrying tokenizer loading...");
+        logger4.info("Retrying tokenizer loading...");
         const tokenizer = await AutoTokenizer.from_pretrained(modelConfig.tokenizer.name, {
           cache_dir: this.modelsDir,
           local_files_only: false
         });
         this.tokenizers.set(tokenizerKey, tokenizer);
-        logger5.success("Tokenizer loaded successfully on retry:", {
+        logger4.success("Tokenizer loaded successfully on retry:", {
           key: tokenizerKey
         });
         return tokenizer;
       }
     } catch (error) {
-      logger5.error("Failed to load tokenizer:", {
+      logger4.error("Failed to load tokenizer:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         model: modelConfig.name,
@@ -1319,23 +965,23 @@ var TokenizerManager = class _TokenizerManager {
    */
   async encode(text, modelConfig) {
     try {
-      logger5.info("Encoding text with tokenizer:", {
+      logger4.info("Encoding text with tokenizer:", {
         length: text.length,
         tokenizer: modelConfig.tokenizer.name
       });
       const tokenizer = await this.loadTokenizer(modelConfig);
-      logger5.info("Tokenizer loaded, encoding text...");
+      logger4.info("Tokenizer loaded, encoding text...");
       const encoded = await tokenizer.encode(text, {
         add_special_tokens: true,
         return_token_type_ids: false
       });
-      logger5.info("Text encoded successfully:", {
+      logger4.info("Text encoded successfully:", {
         tokenCount: encoded.length,
         tokenizer: modelConfig.tokenizer.name
       });
       return encoded;
     } catch (error) {
-      logger5.error("Text encoding failed:", {
+      logger4.error("Text encoding failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         textLength: text.length,
@@ -1355,23 +1001,23 @@ var TokenizerManager = class _TokenizerManager {
    */
   async decode(tokens, modelConfig) {
     try {
-      logger5.info("Decoding tokens with tokenizer:", {
+      logger4.info("Decoding tokens with tokenizer:", {
         count: tokens.length,
         tokenizer: modelConfig.tokenizer.name
       });
       const tokenizer = await this.loadTokenizer(modelConfig);
-      logger5.info("Tokenizer loaded, decoding tokens...");
+      logger4.info("Tokenizer loaded, decoding tokens...");
       const decoded = await tokenizer.decode(tokens, {
         skip_special_tokens: true,
         clean_up_tokenization_spaces: true
       });
-      logger5.info("Tokens decoded successfully:", {
+      logger4.info("Tokens decoded successfully:", {
         textLength: decoded.length,
         tokenizer: modelConfig.tokenizer.name
       });
       return decoded;
     } catch (error) {
-      logger5.error("Token decoding failed:", {
+      logger4.error("Token decoding failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         tokenCount: tokens.length,
@@ -1388,7 +1034,7 @@ import { exec as exec2 } from "node:child_process";
 import fs2 from "node:fs";
 import path2 from "node:path";
 import { promisify as promisify2 } from "node:util";
-import { logger as logger6 } from "@elizaos/core";
+import { logger as logger5 } from "@elizaos/core";
 import { nodewhisper } from "nodejs-whisper";
 var execAsync2 = promisify2(exec2);
 var TranscribeManager = class _TranscribeManager {
@@ -1405,7 +1051,7 @@ var TranscribeManager = class _TranscribeManager {
    */
   constructor(cacheDir) {
     this.cacheDir = path2.join(cacheDir, "whisper");
-    logger6.debug("Initializing TranscribeManager", {
+    logger5.debug("Initializing TranscribeManager", {
       cacheDir: this.cacheDir,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -1421,7 +1067,7 @@ var TranscribeManager = class _TranscribeManager {
         await this.initializeFFmpeg();
         this.ffmpegInitialized = true;
       } catch (error) {
-        logger6.error("FFmpeg initialization failed:", {
+        logger5.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()
@@ -1459,13 +1105,13 @@ var TranscribeManager = class _TranscribeManager {
     try {
       const { stdout } = await execAsync2("ffmpeg -version");
       this.ffmpegVersion = stdout.split("\n")[0];
-      logger6.info("FFmpeg version:", {
+      logger5.info("FFmpeg version:", {
         version: this.ffmpegVersion,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch (error) {
       this.ffmpegVersion = null;
-      logger6.error("Failed to get FFmpeg version:", {
+      logger5.error("Failed to get FFmpeg version:", {
         error: error instanceof Error ? error.message : String(error),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -1488,12 +1134,17 @@ var TranscribeManager = class _TranscribeManager {
       if (this.ffmpegAvailable) {
         await this.fetchFFmpegVersion();
         await this.verifyFFmpegCapabilities();
+        logger5.success("FFmpeg initialized successfully", {
+          version: this.ffmpegVersion,
+          path: this.ffmpegPath,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
       } else {
         this.logFFmpegInstallInstructions();
       }
     } catch (error) {
       this.ffmpegAvailable = false;
-      logger6.error("FFmpeg initialization failed:", {
+      logger5.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()
@@ -1513,7 +1164,7 @@ var TranscribeManager = class _TranscribeManager {
       const { stdout, stderr } = await execAsync2("which ffmpeg || where ffmpeg");
       this.ffmpegPath = stdout.trim();
       this.ffmpegAvailable = true;
-      logger6.info("FFmpeg found at:", {
+      logger5.info("FFmpeg found at:", {
         path: this.ffmpegPath,
         stderr: stderr ? stderr.trim() : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -1521,7 +1172,7 @@ var TranscribeManager = class _TranscribeManager {
     } catch (error) {
       this.ffmpegAvailable = false;
       this.ffmpegPath = null;
-      logger6.error("FFmpeg not found in PATH:", {
+      logger5.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()
@@ -1541,7 +1192,7 @@ var TranscribeManager = class _TranscribeManager {
         throw new Error("FFmpeg installation missing required codecs (pcm_s16le, wav)");
       }
     } catch (error) {
-      logger6.error("FFmpeg capabilities verification failed:", {
+      logger5.error("FFmpeg capabilities verification failed:", {
         error: error instanceof Error ? error.message : String(error),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -1552,7 +1203,7 @@ var TranscribeManager = class _TranscribeManager {
    * Logs instructions on how to install FFmpeg if it is not properly installed.
    */
   logFFmpegInstallInstructions() {
-    logger6.warn("FFmpeg is required but not properly installed. Please install FFmpeg:", {
+    logger5.warn("FFmpeg is required but not properly installed. Please install FFmpeg:", {
       instructions: {
         mac: "brew install ffmpeg",
         ubuntu: "sudo apt-get install ffmpeg",
@@ -1605,7 +1256,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:", {
+        logger5.warn("FFmpeg conversion error:", {
           stderr,
           inputPath,
           outputPath,
@@ -1616,7 +1267,7 @@ var TranscribeManager = class _TranscribeManager {
         throw new Error("WAV file was not created successfully");
       }
     } catch (error) {
-      logger6.error("Audio conversion failed:", {
+      logger5.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}"`,
@@ -1652,7 +1303,7 @@ var TranscribeManager = class _TranscribeManager {
       }
       return tempWavFile;
     } catch (error) {
-      logger6.error("Audio preprocessing failed:", {
+      logger5.error("Audio preprocessing failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         ffmpegAvailable: this.ffmpegAvailable,
@@ -1679,7 +1330,7 @@ var TranscribeManager = class _TranscribeManager {
     }
     try {
       const wavFile = await this.preprocessAudio(audioBuffer);
-      logger6.info("Starting transcription with whisper...");
+      logger5.info("Starting transcription with whisper...");
       const originalStdoutWrite = process.stdout.write;
       const originalStderrWrite = process.stderr.write;
       const noopWrite = () => true;
@@ -1702,19 +1353,19 @@ var TranscribeManager = class _TranscribeManager {
       }
       if (fs2.existsSync(wavFile)) {
         fs2.unlinkSync(wavFile);
-        logger6.info("Temporary WAV file cleaned up");
+        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(" ");
-      logger6.success("Transcription complete:", {
+      logger5.success("Transcription complete:", {
         textLength: cleanText.length,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return { text: cleanText };
     } catch (error) {
-      logger6.error("Transcription failed:", {
+      logger5.error("Transcription failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         ffmpegAvailable: this.ffmpegAvailable
@@ -1728,244 +1379,162 @@ var TranscribeManager = class _TranscribeManager {
 import fs3 from "node:fs";
 import path3 from "node:path";
 import { Readable } from "node:stream";
-import { logger as logger7, prependWavHeader } from "@elizaos/core";
-import {
-  getLlama
-} from "node-llama-cpp";
+import { logger as logger6, prependWavHeader } from "@elizaos/core";
+import { pipeline } from "@huggingface/transformers";
+import { fetch as fetch2 } from "undici";
 var TTSManager = class _TTSManager {
   static instance = null;
   cacheDir;
-  model = null;
-  ctx = null;
-  sequence = null;
+  synthesizer = null;
+  defaultSpeakerEmbedding = null;
   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.
-   */
+  initializingPromise = null;
   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");
-    this.downloadManager = DownloadManager.getInstance(this.cacheDir, this.modelsDir);
     this.ensureCacheDirectory();
-    logger7.debug("TTSManager initialized");
+    logger6.debug("TTSManager using Transformers.js 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.debug("Created TTS cache directory:", this.cacheDir);
+      logger6.debug("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...");
-      const modelSpec = MODEL_SPECS.tts.base;
-      const modelPath = path3.join(this.modelsDir, modelSpec.name);
-      if (!fs3.existsSync(modelPath)) {
-        const attempts = [
-          {
-            spec: { ...modelSpec },
-            description: "Standard URL with GGUF",
-            url: `https://huggingface.co/${modelSpec.repo}/resolve/main/${modelSpec.name}?download=true`
-          },
-          {
-            spec: { ...modelSpec, repo: modelSpec.repo.replace("-GGUF", "") },
-            description: "URL without GGUF suffix",
-            url: `https://huggingface.co/${modelSpec.repo.replace("-GGUF", "")}/resolve/main/${modelSpec.name}?download=true`
-          },
-          {
-            spec: { ...modelSpec, name: modelSpec.name.replace("-Q8_0", "") },
-            description: "URL without quantization suffix",
-            url: `https://huggingface.co/${modelSpec.repo}/resolve/main/${modelSpec.name.replace("-Q8_0", "")}.gguf?download=true`
-          }
-        ];
-        let lastError = null;
-        for (const attempt of attempts) {
-          try {
-            logger7.info("Attempting TTS model download:", {
-              description: attempt.description,
-              repo: attempt.spec.repo,
-              name: attempt.spec.name,
-              url: attempt.url,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-            const barLength = 30;
-            const emptyBar = "\u25B1".repeat(barLength);
-            logger7.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("TTS model download successful with:", attempt.description);
-            break;
-          } catch (error) {
-            lastError = error;
-            logger7.warn("TTS model download attempt failed:", {
-              description: attempt.description,
-              error: error instanceof Error ? error.message : String(error),
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
+    if (this.initializingPromise) {
+      logger6.debug("TTS initialization already in progress, awaiting existing promise.");
+      return this.initializingPromise;
+    }
+    if (this.initialized) {
+      logger6.debug("TTS already initialized.");
+      return;
+    }
+    this.initializingPromise = (async () => {
+      try {
+        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.");
+        }
+        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}`);
+        if (speakerEmbeddingUrl) {
+          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...");
+            const buffer = fs3.readFileSync(embeddingPath);
+            this.defaultSpeakerEmbedding = new Float32Array(
+              buffer.buffer,
+              buffer.byteOffset,
+              buffer.length / Float32Array.BYTES_PER_ELEMENT
+            );
+            logger6.success("Default speaker embedding loaded from cache.");
+          } else {
+            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}`);
+            }
+            const buffer = await response.arrayBuffer();
+            this.defaultSpeakerEmbedding = new Float32Array(buffer);
+            fs3.writeFileSync(embeddingPath, Buffer.from(buffer));
+            logger6.success("Default speaker embedding downloaded and cached.");
           }
+        } else {
+          logger6.warn(
+            `No default speaker embedding URL specified for model ${modelName}. Speaker control may be limited.`
+          );
+          this.defaultSpeakerEmbedding = null;
         }
-        if (!fs3.existsSync(modelPath)) {
-          throw lastError || new Error("All download attempts failed");
+        if (!this.synthesizer) {
+          throw new Error("TTS initialization failed: Pipeline not loaded.");
         }
+        logger6.success("TTS initialization complete (Transformers.js)");
+        this.initialized = true;
+      } catch (error) {
+        logger6.error("TTS (Transformers.js) initialization failed:", {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+        this.initialized = false;
+        this.synthesizer = null;
+        this.defaultSpeakerEmbedding = null;
+        throw error;
+      } finally {
+        this.initializingPromise = null;
+        logger6.debug("TTS initializingPromise cleared after completion/failure.");
       }
-      logger7.info("Loading TTS model...");
-      const llama = await getLlama();
-      this.model = await llama.loadModel({
-        modelPath,
-        gpuLayers: 0
-        // Force CPU for now until we add GPU support
-      });
-      this.ctx = await this.model.createContext({
-        contextSize: modelSpec.contextSize
-      });
-      this.sequence = this.ctx.getSequence();
-      logger7.success("TTS initialization complete", {
-        modelPath,
-        contextSize: modelSpec.contextSize,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      this.initialized = true;
-    } catch (error) {
-      logger7.error("TTS initialization failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        model: MODEL_SPECS.tts.base.name,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    }
+    })();
+    return this.initializingPromise;
   }
   /**
-   * Asynchronously generates speech from a given text using the initialized TTS model.
+   * Asynchronously generates speech from a given text using the Transformers.js pipeline.
    * @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.
+   * @returns {Promise<Readable>} A promise that resolves to a Readable stream containing the generated WAV audio data.
+   * @throws {Error} If the TTS model is not initialized or if generation fails.
    */
   async generateSpeech(text) {
     try {
       await this.initialize();
-      if (!this.model || !this.ctx || !this.sequence) {
-        throw new Error("TTS model not initialized");
+      if (!this.synthesizer) {
+        throw new Error("TTS Manager not properly initialized.");
       }
-      logger7.info("Starting speech generation for text:", { text });
-      const prompt = `[SPEAKER=female_1][LANGUAGE=en]${text}`;
-      logger7.info("Formatted prompt:", { prompt });
-      logger7.info("Tokenizing input...");
-      const inputTokens = this.model.tokenize(prompt);
-      logger7.info("Input tokenized:", { tokenCount: inputTokens.length });
-      const maxTokens = inputTokens.length * 2;
-      logger7.info("Starting token generation with optimized limit:", {
-        maxTokens
+      logger6.info("Starting speech generation with Transformers.js for text:", {
+        text: text.substring(0, 50) + "..."
       });
-      const responseTokens = [];
-      const _startTime = Date.now();
-      try {
-        for await (const token of this.sequence.evaluate(inputTokens, {
-          temperature: 0.1
-        })) {
-          responseTokens.push(token);
-          const percent = Math.round(responseTokens.length / maxTokens * 100);
-          const barLength = 30;
-          const filledLength = Math.floor(responseTokens.length / maxTokens * barLength);
-          const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-          logger7.info(
-            `Token generation: ${progressBar} ${percent}% (${responseTokens.length}/${maxTokens})`
-          );
-          if (responseTokens.length >= maxTokens) {
-            logger7.info("Token generation complete");
-            break;
-          }
-        }
-      } catch (error) {
-        logger7.error("Token generation error:", error);
-        throw error;
+      const output = await this.synthesizer(text, {
+        // Pass embedding only if it was loaded
+        ...this.defaultSpeakerEmbedding && { speaker_embeddings: this.defaultSpeakerEmbedding }
+      });
+      const audioFloat32 = output.audio;
+      const samplingRate = output.sampling_rate;
+      logger6.info("Raw audio data received from pipeline:", {
+        samplingRate,
+        length: audioFloat32.length
+      });
+      if (!audioFloat32 || audioFloat32.length === 0) {
+        throw new Error("TTS pipeline generated empty audio output.");
       }
-      if (responseTokens.length === 0) {
-        throw new Error("No audio tokens generated");
+      const pcmData = new Int16Array(audioFloat32.length);
+      for (let i = 0; i < audioFloat32.length; i++) {
+        const s = Math.max(-1, Math.min(1, audioFloat32[i]));
+        pcmData[i] = s < 0 ? s * 32768 : s * 32767;
       }
-      logger7.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:", {
-        byteLength: audioData.length,
-        sampleRate: MODEL_SPECS.tts.base.sampleRate
+      const audioBuffer = Buffer.from(pcmData.buffer);
+      logger6.info("Audio data converted to 16-bit PCM Buffer:", {
+        byteLength: audioBuffer.length
       });
       const audioStream = prependWavHeader(
-        Readable.from(audioData),
-        audioData.length,
-        MODEL_SPECS.tts.base.sampleRate,
+        Readable.from(audioBuffer),
+        audioBuffer.length,
+        // Pass buffer length in bytes
+        samplingRate,
         1,
+        // Number of channels (assuming mono)
         16
+        // Bit depth
       );
-      logger7.success("Speech generation complete");
+      logger6.success("Speech generation complete (Transformers.js)");
       return audioStream;
     } catch (error) {
-      logger7.error("Speech generation failed:", {
+      logger6.error("Transformers.js speech generation failed:", {
         error: error instanceof Error ? error.message : String(error),
-        text
+        text: text.substring(0, 50) + "...",
+        stack: error instanceof Error ? error.stack : void 0
       });
       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);
-      for (let i = 0; i < response.audio.length; i++) {
-        const s = Math.max(-1, Math.min(1, response.audio[i]));
-        pcmData2[i] = s < 0 ? s * 32768 : s * 32767;
-      }
-      return Buffer.from(pcmData2.buffer);
-    }
-    const pcmData = new Int16Array(response.tokens.length * 2);
-    for (let i = 0; i < response.tokens.length; i++) {
-      pcmData[i * 2] = response.tokens[i] & 65535;
-      pcmData[i * 2 + 1] = response.tokens[i] >> 16 & 65535;
-    }
-    return Buffer.from(pcmData.buffer);
-  }
 };
 
 // src/utils/visionManager.ts
@@ -1974,7 +1543,7 @@ import fs4 from "node:fs";
 import os2 from "node:os";
 import path4 from "node:path";
 import process2 from "node:process";
-import { logger as logger8 } from "@elizaos/core";
+import { logger as logger7 } from "@elizaos/core";
 import {
   AutoProcessor,
   AutoTokenizer as AutoTokenizer2,
@@ -2012,7 +1581,7 @@ var VisionManager = class _VisionManager {
     this.ensureModelsDirExists();
     this.downloadManager = DownloadManager.getInstance(this.cacheDir, this.modelsDir);
     this.platformConfig = this.getPlatformConfig();
-    logger8.debug("VisionManager initialized");
+    logger7.debug("VisionManager initialized");
   }
   /**
    * Retrieves the platform configuration based on the operating system and architecture.
@@ -2049,7 +1618,7 @@ var VisionManager = class _VisionManager {
    */
   ensureModelsDirExists() {
     if (!existsSync(this.modelsDir)) {
-      logger8.debug(`Creating models directory at: ${this.modelsDir}`);
+      logger7.debug(`Creating models directory at: ${this.modelsDir}`);
       fs4.mkdirSync(this.modelsDir, { recursive: true });
     }
   }
@@ -2076,7 +1645,7 @@ var VisionManager = class _VisionManager {
   checkCacheExists(modelId, type) {
     const modelPath = path4.join(this.modelsDir, modelId.replace("/", "--"), type);
     if (existsSync(modelPath)) {
-      logger8.info(`${type} found at: ${modelPath}`);
+      logger7.info(`${type} found at: ${modelPath}`);
       return true;
     }
     return false;
@@ -2099,7 +1668,7 @@ var VisionManager = class _VisionManager {
       ...component,
       dtype: defaultDtype
     }));
-    logger8.info("Model components configured with dtype:", {
+    logger7.info("Model components configured with dtype:", {
       platform,
       arch,
       defaultDtype,
@@ -2128,19 +1697,19 @@ var VisionManager = class _VisionManager {
   async initialize() {
     try {
       if (this.initialized) {
-        logger8.info("Vision model already initialized, skipping initialization");
+        logger7.info("Vision model already initialized, skipping initialization");
         return;
       }
-      logger8.info("Starting vision model initialization...");
+      logger7.info("Starting vision model initialization...");
       const modelSpec = MODEL_SPECS.vision;
-      logger8.info("Configuring environment for vision model...");
+      logger7.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...");
+      logger7.info("Loading Florence2 model...");
       try {
         let lastProgress = -1;
         const modelCached = this.checkCacheExists(modelSpec.modelId, "model");
@@ -2158,22 +1727,22 @@ var VisionManager = class _VisionManager {
               const barLength = 30;
               const filledLength = Math.floor(currentProgress / 100 * barLength);
               const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger8.info(`Downloading vision model: ${progressBar} ${currentProgress}%`);
+              logger7.info(`Downloading vision model: ${progressBar} ${currentProgress}%`);
               if (currentProgress === 100) this.modelDownloaded = true;
             }
           }
         });
         this.model = model;
-        logger8.success("Florence2 model loaded successfully");
+        logger7.success("Florence2 model loaded successfully");
       } catch (error) {
-        logger8.error("Failed to load Florence2 model:", {
+        logger7.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...");
+      logger7.info("Loading vision tokenizer...");
       try {
         const tokenizerCached = this.checkCacheExists(modelSpec.modelId, "tokenizer");
         let tokenizerProgress = -1;
@@ -2189,21 +1758,21 @@ var VisionManager = class _VisionManager {
               const barLength = 30;
               const filledLength = Math.floor(currentProgress / 100 * barLength);
               const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger8.info(`Downloading vision tokenizer: ${progressBar} ${currentProgress}%`);
+              logger7.info(`Downloading vision tokenizer: ${progressBar} ${currentProgress}%`);
               if (currentProgress === 100) this.tokenizerDownloaded = true;
             }
           }
         });
-        logger8.success("Vision tokenizer loaded successfully");
+        logger7.success("Vision tokenizer loaded successfully");
       } catch (error) {
-        logger8.error("Failed to load tokenizer:", {
+        logger7.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...");
+      logger7.info("Loading vision processor...");
       try {
         const processorCached = this.checkCacheExists(modelSpec.modelId, "processor");
         let processorProgress = -1;
@@ -2220,14 +1789,14 @@ var VisionManager = class _VisionManager {
               const barLength = 30;
               const filledLength = Math.floor(currentProgress / 100 * barLength);
               const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger8.info(`Downloading vision processor: ${progressBar} ${currentProgress}%`);
+              logger7.info(`Downloading vision processor: ${progressBar} ${currentProgress}%`);
               if (currentProgress === 100) this.processorDownloaded = true;
             }
           }
         });
-        logger8.success("Vision processor loaded successfully");
+        logger7.success("Vision processor loaded successfully");
       } catch (error) {
-        logger8.error("Failed to load vision processor:", {
+        logger7.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
@@ -2235,9 +1804,9 @@ var VisionManager = class _VisionManager {
         throw error;
       }
       this.initialized = true;
-      logger8.success("Vision model initialization complete");
+      logger7.success("Vision model initialization complete");
     } catch (error) {
-      logger8.error("Vision model initialization failed:", {
+      logger7.error("Vision model initialization failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         modelsDir: this.modelsDir
@@ -2253,13 +1822,13 @@ var VisionManager = class _VisionManager {
    */
   async fetchImage(url) {
     try {
-      logger8.info(`Fetching image from URL: ${url.slice(0, 100)}...`);
+      logger7.info(`Fetching image from URL: ${url.slice(0, 100)}...`);
       if (url.startsWith("data:")) {
-        logger8.info("Processing data URL...");
+        logger7.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");
+        logger7.info("Data URL processed successfully");
         return { buffer: buffer2, mimeType: mimeType2 };
       }
       const response = await fetch(url);
@@ -2268,14 +1837,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:", {
+      logger7.info("Image fetched successfully:", {
         mimeType,
         bufferSize: buffer.length,
         status: response.status
       });
       return { buffer, mimeType };
     } catch (error) {
-      logger8.error("Failed to fetch image:", {
+      logger7.error("Failed to fetch image:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         url
@@ -2290,37 +1859,37 @@ var VisionManager = class _VisionManager {
    */
   async processImage(imageUrl) {
     try {
-      logger8.info("Starting image processing...");
+      logger7.info("Starting image processing...");
       if (!this.initialized) {
-        logger8.info("Vision model not initialized, initializing now...");
+        logger7.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...");
+      logger7.info("Fetching image...");
       const { buffer, mimeType } = await this.fetchImage(imageUrl);
-      logger8.info("Creating image blob...");
+      logger7.info("Creating image blob...");
       const blob = new Blob([buffer], { type: mimeType });
-      logger8.info("Converting blob to RawImage...");
+      logger7.info("Converting blob to RawImage...");
       const image = await RawImage.fromBlob(blob);
-      logger8.info("Processing image with vision processor...");
+      logger7.info("Processing image with vision processor...");
       const visionInputs = await this.processor(image);
-      logger8.info("Constructing prompts...");
+      logger7.info("Constructing prompts...");
       const prompts = this.processor.construct_prompts("<DETAILED_CAPTION>");
-      logger8.info("Tokenizing prompts...");
+      logger7.info("Tokenizing prompts...");
       const textInputs = this.tokenizer(prompts);
-      logger8.info("Generating image description...");
+      logger7.info("Generating image description...");
       const generatedIds = await this.model.generate({
         ...textInputs,
         ...visionInputs,
         max_new_tokens: MODEL_SPECS.vision.maxTokens
       });
-      logger8.info("Decoding generated text...");
+      logger7.info("Decoding generated text...");
       const generatedText = this.tokenizer.batch_decode(generatedIds, {
         skip_special_tokens: false
       })[0];
-      logger8.info("Post-processing generation...");
+      logger7.info("Post-processing generation...");
       const result = this.processor.post_process_generation(
         generatedText,
         "<DETAILED_CAPTION>",
@@ -2331,13 +1900,13 @@ var VisionManager = class _VisionManager {
         title: `${detailedCaption.split(".")[0]}.`,
         description: detailedCaption
       };
-      logger8.success("Image processing complete:", {
+      logger7.success("Image processing complete:", {
         titleLength: response.title.length,
         descriptionLength: response.description.length
       });
       return response;
     } catch (error) {
-      logger8.error("Image processing failed:", {
+      logger7.error("Image processing failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         imageUrl,
@@ -2352,8 +1921,7 @@ var VisionManager = class _VisionManager {
 };
 
 // src/index.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path5.dirname(__filename);
+import { basename } from "path";
 var wordsToPunish = [
   " please",
   " feel",
@@ -2425,15 +1993,17 @@ var LocalAIManager = class _LocalAIManager {
   embeddingModelConfig;
   transcribeManager;
   ttsManager;
-  studioLMManager;
+  config = null;
+  // Store validated config
   // Initialization state flag
-  studioLMInitialized = false;
   smallModelInitialized = false;
   mediumModelInitialized = false;
   embeddingInitialized = false;
   visionInitialized = false;
   transcriptionInitialized = false;
   ttsInitialized = false;
+  environmentInitialized = false;
+  // Add flag for environment initialization
   // Initialization promises to prevent duplicate initialization
   smallModelInitializingPromise = null;
   mediumModelInitializingPromise = null;
@@ -2441,47 +2011,81 @@ var LocalAIManager = class _LocalAIManager {
   visionInitializingPromise = null;
   transcriptionInitializingPromise = null;
   ttsInitializingPromise = null;
-  studioLMInitializingPromise = null;
+  environmentInitializingPromise = null;
+  // Add promise for environment
   modelsDir;
   /**
    * Private constructor function to initialize base managers and paths.
-   * This now only sets up the basic infrastructure without loading any models.
+   * Model paths are set after environment initialization.
    */
   constructor() {
-    const modelsDir = path5.join(os3.homedir(), ".eliza", "models");
-    if (process.env.LLAMALOCAL_PATH?.trim()) {
-      this.modelsDir = path5.resolve(process.env.LLAMALOCAL_PATH.trim());
+    this.config = validateConfig();
+    this._setupCacheDir();
+    this.activeModelConfig = MODEL_SPECS.small;
+    this.embeddingModelConfig = MODEL_SPECS.embedding;
+  }
+  /**
+   * Post-validation initialization steps that require config to be set.
+   * Called after config validation in initializeEnvironment.
+   */
+  _postValidateInit() {
+    this._setupModelsDir();
+    this.downloadManager = DownloadManager.getInstance(this.cacheDir, this.modelsDir);
+    this.tokenizerManager = TokenizerManager.getInstance(this.cacheDir, this.modelsDir);
+    this.visionManager = VisionManager.getInstance(this.cacheDir);
+    this.transcribeManager = TranscribeManager.getInstance(this.cacheDir);
+    this.ttsManager = TTSManager.getInstance(this.cacheDir);
+  }
+  /**
+   * Sets up the models directory, reading from config or environment variables,
+   * and ensures the directory exists.
+   */
+  _setupModelsDir() {
+    const modelsDirEnv = this.config?.MODELS_DIR?.trim() || process.env.MODELS_DIR?.trim();
+    if (modelsDirEnv) {
+      this.modelsDir = path5.resolve(modelsDirEnv);
+      logger8.info("Using models directory from MODELS_DIR environment variable:", this.modelsDir);
     } else {
-      if (!fs5.existsSync(modelsDir)) {
-        fs5.mkdirSync(modelsDir, { recursive: true });
-        logger9.debug("Created models directory");
-      }
-      this.modelsDir = modelsDir;
+      this.modelsDir = path5.join(os3.homedir(), ".eliza", "models");
+      logger8.info(
+        "MODELS_DIR environment variable not set, using default models directory:",
+        this.modelsDir
+      );
+    }
+    if (!fs5.existsSync(this.modelsDir)) {
+      fs5.mkdirSync(this.modelsDir, { recursive: true });
+      logger8.debug("Ensured models directory exists (created):", this.modelsDir);
+    } else {
+      logger8.debug("Models directory already exists:", this.modelsDir);
     }
-    this.modelPath = path5.join(this.modelsDir, "DeepHermes-3-Llama-3-3B-Preview-q4.gguf");
-    this.mediumModelPath = path5.join(this.modelsDir, "DeepHermes-3-Llama-3-8B-q4.gguf");
-    this.embeddingModelPath = path5.join(this.modelsDir, "bge-small-en-v1.5.Q4_K_M.gguf");
-    const cacheDirEnv = process.env.CACHE_DIR?.trim();
+  }
+  /**
+   * Sets up the cache directory, reading from config or environment variables,
+   * and ensures the directory exists.
+   */
+  _setupCacheDir() {
+    const cacheDirEnv = this.config?.CACHE_DIR?.trim() || process.env.CACHE_DIR?.trim();
     if (cacheDirEnv) {
       this.cacheDir = path5.resolve(cacheDirEnv);
+      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)) {
         fs5.mkdirSync(cacheDir, { recursive: true });
-        logger9.debug("Ensuring cache directory exists:", cacheDir);
+        logger8.debug("Ensuring cache directory exists (created):", cacheDir);
       }
       this.cacheDir = cacheDir;
+      logger8.info(
+        "CACHE_DIR environment variable not set, using default cache directory:",
+        this.cacheDir
+      );
     }
-    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);
-    if (process.env.USE_STUDIOLM_TEXT_MODELS === "true") {
-      this.studioLMManager = StudioLMManager.getInstance();
+    if (!fs5.existsSync(this.cacheDir)) {
+      fs5.mkdirSync(this.cacheDir, { recursive: true });
+      logger8.debug("Ensured cache directory exists (created):", this.cacheDir);
+    } else {
+      logger8.debug("Cache directory already exists:", this.cacheDir);
     }
-    this.activeModelConfig = MODEL_SPECS.small;
-    this.embeddingModelConfig = MODEL_SPECS.embedding;
   }
   /**
    * Retrieves the singleton instance of LocalAIManager. If an instance does not already exist, a new one is created and returned.
@@ -2494,55 +2098,41 @@ var LocalAIManager = class _LocalAIManager {
     return _LocalAIManager.instance;
   }
   /**
-   * Initializes the environment by validating the configuration and setting the environment variables with the validated values.
+   * Initializes the environment by validating the configuration and setting model paths.
+   * Now public to be callable from plugin init and model handlers.
    *
    * @returns {Promise<void>} A Promise that resolves once the environment has been successfully initialized.
    */
   async initializeEnvironment() {
-    try {
-      logger9.info("Validating environment configuration...");
-      const config = {
-        USE_LOCAL_AI: process.env.USE_LOCAL_AI,
-        USE_STUDIOLM_TEXT_MODELS: process.env.USE_STUDIOLM_TEXT_MODELS
-      };
-      const validatedConfig = await validateConfig(config);
-      logger9.info("Environment configuration validated");
-      process.env.USE_LOCAL_AI = String(validatedConfig.USE_LOCAL_AI);
-      process.env.USE_STUDIOLM_TEXT_MODELS = String(validatedConfig.USE_STUDIOLM_TEXT_MODELS);
-      logger9.success("Environment initialization complete");
-    } catch (error) {
-      logger9.error("Environment validation failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0
-      });
-      throw error;
+    if (this.environmentInitialized) return;
+    if (this.environmentInitializingPromise) {
+      await this.environmentInitializingPromise;
+      return;
     }
-  }
-  /**
-   * 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 {
-      logger9.info("Initializing StudioLM models...");
-      if (!this.studioLMManager) {
-        throw new Error("StudioLM manager not created - cannot initialize");
-      }
-      await this.studioLMManager.initialize();
-      if (!this.studioLMManager.isInitialized()) {
-        throw new Error("StudioLM initialization failed - models not properly loaded");
+    this.environmentInitializingPromise = (async () => {
+      try {
+        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);
+        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("Environment configuration validated and model paths set");
+        this.environmentInitialized = true;
+        logger8.success("Environment initialization complete");
+      } catch (error) {
+        logger8.error("Environment validation failed:", {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+        this.environmentInitializingPromise = null;
+        throw error;
       }
-      this.studioLMInitialized = true;
-      logger9.success("StudioLM initialization complete");
-    } catch (error) {
-      logger9.error("StudioLM 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;
-    }
+    })();
+    await this.environmentInitializingPromise;
   }
   /**
    * Downloads the model based on the modelPath provided.
@@ -2554,24 +2144,25 @@ var LocalAIManager = class _LocalAIManager {
    */
   async downloadModel(modelType, customModelSpec) {
     let modelSpec;
-    let modelPath;
+    let modelPathToDownload;
+    await this.initializeEnvironment();
     if (customModelSpec) {
       modelSpec = customModelSpec;
-      modelPath = modelType === ModelType2.TEXT_EMBEDDING ? this.embeddingModelPath : modelType === ModelType2.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
-    } else if (modelType === ModelType2.TEXT_EMBEDDING) {
+      modelPathToDownload = modelType === ModelType.TEXT_EMBEDDING ? this.embeddingModelPath : modelType === ModelType.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
+    } else if (modelType === ModelType.TEXT_EMBEDDING) {
       modelSpec = MODEL_SPECS.embedding;
-      modelPath = this.embeddingModelPath;
+      modelPathToDownload = this.embeddingModelPath;
     } else {
-      modelSpec = modelType === ModelType2.TEXT_LARGE ? MODEL_SPECS.medium : MODEL_SPECS.small;
-      modelPath = modelType === ModelType2.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
+      modelSpec = modelType === ModelType.TEXT_LARGE ? MODEL_SPECS.medium : MODEL_SPECS.small;
+      modelPathToDownload = modelType === ModelType.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
     }
     try {
-      return await this.downloadManager.downloadModel(modelSpec, modelPath);
+      return await this.downloadManager.downloadModel(modelSpec, modelPathToDownload);
     } catch (error) {
-      logger9.error("Model download failed:", {
+      logger8.error("Model download failed:", {
         error: error instanceof Error ? error.message : String(error),
         modelType,
-        modelPath
+        modelPath: modelPathToDownload
       });
       throw error;
     }
@@ -2586,14 +2177,14 @@ var LocalAIManager = class _LocalAIManager {
       const platformManager = getPlatformManager();
       await platformManager.initialize();
       const capabilities = platformManager.getCapabilities();
-      logger9.info("Platform capabilities detected:", {
+      logger8.info("Platform capabilities detected:", {
         platform: capabilities.platform,
         gpu: capabilities.gpu?.type || "none",
         recommendedModel: capabilities.recommendedModelSize,
         supportedBackends: capabilities.supportedBackends
       });
     } catch (error) {
-      logger9.warn("Platform detection failed:", error);
+      logger8.warn("Platform detection failed:", error);
     }
   }
   /**
@@ -2602,8 +2193,9 @@ var LocalAIManager = class _LocalAIManager {
    * @param {ModelTypeName} modelType - The type of model to initialize (default: ModelType.TEXT_SMALL)
    * @returns {Promise<void>} A promise that resolves when initialization is complete or rejects if an error occurs
    */
-  async initialize(modelType = ModelType2.TEXT_SMALL) {
-    if (modelType === ModelType2.TEXT_LARGE) {
+  async initialize(modelType = ModelType.TEXT_SMALL) {
+    await this.initializeEnvironment();
+    if (modelType === ModelType.TEXT_LARGE) {
       await this.lazyInitMediumModel();
     } else {
       await this.lazyInitSmallModel();
@@ -2616,20 +2208,22 @@ var LocalAIManager = class _LocalAIManager {
    */
   async initializeEmbedding() {
     try {
-      logger9.info("Initializing embedding model...");
-      logger9.info("Models directory:", this.modelsDir);
+      await this.initializeEnvironment();
+      logger8.info("Initializing embedding model...");
+      logger8.info("Models directory:", this.modelsDir);
       if (!fs5.existsSync(this.modelsDir)) {
-        logger9.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(ModelType2.TEXT_EMBEDDING);
+      await this.downloadModel(ModelType.TEXT_EMBEDDING);
       if (!this.llama) {
-        this.llama = await getLlama2();
+        this.llama = await getLlama();
       }
       if (!this.embeddingModel) {
-        logger9.info("Loading embedding model:", this.embeddingModelPath);
+        logger8.info("Loading embedding model:", this.embeddingModelPath);
         this.embeddingModel = await this.llama.loadModel({
           modelPath: this.embeddingModelPath,
+          // Use the correct path
           gpuLayers: 0,
           // Embedding models are typically small enough to run on CPU
           vocabOnly: false
@@ -2638,14 +2232,15 @@ var LocalAIManager = class _LocalAIManager {
           contextSize: this.embeddingModelConfig.contextSize,
           batchSize: 512
         });
-        logger9.success("Embedding model initialized successfully");
+        logger8.success("Embedding model initialized successfully");
       }
     } catch (error) {
-      logger9.error("Embedding initialization failed with details:", {
+      logger8.error("Embedding initialization failed with details:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         modelsDir: this.modelsDir,
         embeddingModelPath: this.embeddingModelPath
+        // Log the path being used
       });
       throw error;
     }
@@ -2659,19 +2254,19 @@ var LocalAIManager = class _LocalAIManager {
       if (!this.embeddingModel || !this.embeddingContext) {
         throw new Error("Failed to initialize embedding model");
       }
-      logger9.info("Generating embedding for text", { textLength: text.length });
+      logger8.info("Generating embedding for text", { textLength: text.length });
       const embeddingResult = await this.embeddingContext.getEmbeddingFor(text);
       const mutableEmbedding = [...embeddingResult.vector];
       const normalizedEmbedding = this.normalizeEmbedding(mutableEmbedding);
-      logger9.info("Embedding generation complete", { dimensions: normalizedEmbedding.length });
+      logger8.info("Embedding generation complete", { dimensions: normalizedEmbedding.length });
       return normalizedEmbedding;
     } catch (error) {
-      logger9.error("Embedding generation failed:", {
+      logger8.error("Embedding generation failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         textLength: text?.length ?? "text is null"
       });
-      const zeroDimensions = process.env.LOCAL_EMBEDDING_DIMENSIONS ? parseInt(process.env.LOCAL_EMBEDDING_DIMENSIONS, 10) : this.embeddingModelConfig.dimensions;
+      const zeroDimensions = this.config?.LOCAL_EMBEDDING_DIMENSIONS ? this.config.LOCAL_EMBEDDING_DIMENSIONS : this.embeddingModelConfig.dimensions;
       return new Array(zeroDimensions).fill(0);
     }
   }
@@ -2698,9 +2293,9 @@ var LocalAIManager = class _LocalAIManager {
       this.embeddingInitializingPromise = (async () => {
         try {
           await this.initializeEnvironment();
-          await this.downloadModel(ModelType2.TEXT_EMBEDDING);
+          await this.downloadModel(ModelType.TEXT_EMBEDDING);
           if (!this.llama) {
-            this.llama = await getLlama2();
+            this.llama = await getLlama();
           }
           this.embeddingModel = await this.llama.loadModel({
             modelPath: this.embeddingModelPath,
@@ -2713,9 +2308,9 @@ var LocalAIManager = class _LocalAIManager {
             batchSize: 512
           });
           this.embeddingInitialized = true;
-          logger9.info("Embedding model initialized successfully");
+          logger8.info("Embedding model initialized successfully");
         } catch (error) {
-          logger9.error("Failed to initialize embedding model:", error);
+          logger8.error("Failed to initialize embedding model:", error);
           this.embeddingInitializingPromise = null;
           throw error;
         }
@@ -2723,55 +2318,15 @@ var LocalAIManager = class _LocalAIManager {
     }
     await this.embeddingInitializingPromise;
   }
-  /**
-   * Asynchronously generates text using StudioLM 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 generateTextLMStudio(params) {
-    try {
-      const modelConfig = this.getTextModelSource();
-      logger9.info("generateTextLMStudio called with:", {
-        modelSource: modelConfig.source,
-        modelType: params.modelType,
-        studioLMInitialized: this.studioLMInitialized,
-        studioLMEnabled: process.env.USE_STUDIOLM_TEXT_MODELS === "true"
-      });
-      if (modelConfig.source === "studiolm") {
-        if (process.env.USE_STUDIOLM_TEXT_MODELS !== "true") {
-          logger9.warn(
-            "StudioLM requested but disabled in environment, falling back to local models"
-          );
-          return this.generateText(params);
-        }
-        if (!this.studioLMManager) {
-          logger9.warn("StudioLM manager not initialized, falling back to local models");
-          return this.generateText(params);
-        }
-        if (!this.studioLMInitialized) {
-          logger9.info("StudioLM not initialized, initializing now...");
-          await this.initializeStudioLM();
-        }
-        return await this.studioLMManager.generateText(params, this.studioLMInitialized);
-      }
-      return this.generateText(params);
-    } catch (error) {
-      logger9.error("Text generation with StudioLM failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        modelSource: this.getTextModelSource().source
-      });
-      return this.generateText(params);
-    }
-  }
   /**
    * Asynchronously generates text based on the provided parameters.
    * Now uses lazy initialization for models
    */
   async generateText(params) {
     try {
-      if (params.modelType === ModelType2.TEXT_LARGE) {
+      await this.initializeEnvironment();
+      logger8.info("Generating text with model:", params.modelType);
+      if (params.modelType === ModelType.TEXT_LARGE) {
         await this.lazyInitMediumModel();
         if (!this.mediumModel) {
           throw new Error("Medium model initialization failed");
@@ -2802,15 +2357,15 @@ var LocalAIManager = class _LocalAIManager {
       if (!this.chatSession) {
         throw new Error("Failed to create chat session");
       }
-      logger9.info("Created new chat session for model:", params.modelType);
-      logger9.info("Incoming prompt structure:", {
+      logger8.info("Created new chat session for model:", params.modelType);
+      logger8.info("Incoming prompt structure:", {
         contextLength: params.prompt.length,
         hasAction: params.prompt.includes("action"),
         runtime: !!params.runtime,
         stopSequences: params.stopSequences
       });
       const tokens = await this.tokenizerManager.encode(params.prompt, this.activeModelConfig);
-      logger9.info("Input tokens:", { count: tokens.length });
+      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, {
         maxTokens: 1,
@@ -2828,19 +2383,19 @@ var LocalAIManager = class _LocalAIManager {
           presencePenalty: 0.7
         }
       });
-      logger9.info("Raw response structure:", {
+      logger8.info("Raw response structure:", {
         responseLength: response.length,
         hasAction: response.includes("action"),
         hasThinkTag: response.includes("<think>")
       });
       if (response.includes("<think>")) {
-        logger9.info("Cleaning think tags from response");
+        logger8.info("Cleaning think tags from response");
         response = response.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-        logger9.info("Think tags removed from response");
+        logger8.info("Think tags removed from response");
       }
       return response;
     } catch (error) {
-      logger9.error("Text generation failed:", error);
+      logger8.error("Text generation failed:", error);
       throw error;
     }
   }
@@ -2854,7 +2409,7 @@ var LocalAIManager = class _LocalAIManager {
       const dataUrl = `data:${mimeType};base64,${base64}`;
       return await this.visionManager.processImage(dataUrl);
     } catch (error) {
-      logger9.error("Image description failed:", error);
+      logger8.error("Image description failed:", error);
       throw error;
     }
   }
@@ -2867,7 +2422,7 @@ var LocalAIManager = class _LocalAIManager {
       const result = await this.transcribeManager.transcribe(audioBuffer);
       return result.text;
     } catch (error) {
-      logger9.error("Audio transcription failed:", {
+      logger8.error("Audio transcription failed:", {
         error: error instanceof Error ? error.message : String(error),
         bufferSize: audioBuffer.length
       });
@@ -2882,14 +2437,13 @@ var LocalAIManager = class _LocalAIManager {
       await this.lazyInitTTS();
       return await this.ttsManager.generateSpeech(text);
     } catch (error) {
-      logger9.error("Speech generation failed:", {
+      logger8.error("Speech generation failed:", {
         error: error instanceof Error ? error.message : String(error),
         textLength: text.length
       });
       throw error;
     }
   }
-  // Add public accessor methods
   /**
    * Returns the TokenizerManager associated with this object.
    *
@@ -2905,41 +2459,6 @@ var LocalAIManager = class _LocalAIManager {
   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 = {
-        source: "local",
-        modelType: ModelType2.TEXT_SMALL
-      };
-      if (process.env.USE_STUDIOLM_TEXT_MODELS === "true" && this.studioLMManager) {
-        config.source = "studiolm";
-      }
-      logger9.info("Selected text model source:", config);
-      return config;
-    } catch (error) {
-      logger9.error("Error determining text model source:", error);
-      return { source: "local", modelType: ModelType2.TEXT_SMALL };
-    }
-  }
-  /**
-   * Generic lazy initialization handler for any model type
-   */
-  async lazyInitialize(modelType, isInitialized, initPromise, initFunction) {
-    if (isInitialized) {
-      return Promise.resolve(null);
-    }
-    if (initPromise) {
-      logger9.info(`Waiting for ${modelType} initialization to complete...`);
-      await initPromise;
-      return Promise.resolve(null);
-    }
-    logger9.info(`Lazy initializing ${modelType}...`);
-    return initFunction();
-  }
   /**
    * Lazy initialize the small text model
    */
@@ -2949,12 +2468,13 @@ var LocalAIManager = class _LocalAIManager {
       this.smallModelInitializingPromise = (async () => {
         await this.initializeEnvironment();
         await this.checkPlatformCapabilities();
-        await this.downloadModel(ModelType2.TEXT_SMALL);
+        await this.downloadModel(ModelType.TEXT_SMALL);
         try {
-          this.llama = await getLlama2();
+          this.llama = await getLlama();
           const smallModel = await this.llama.loadModel({
             gpuLayers: 43,
             modelPath: this.modelPath,
+            // Use the potentially overridden path
             vocabOnly: false
           });
           this.smallModel = smallModel;
@@ -2964,9 +2484,9 @@ var LocalAIManager = class _LocalAIManager {
           this.ctx = ctx;
           this.sequence = void 0;
           this.smallModelInitialized = true;
-          logger9.info("Small model initialized successfully");
+          logger8.info("Small model initialized successfully");
         } catch (error) {
-          logger9.error("Failed to initialize small model:", error);
+          logger8.error("Failed to initialize small model:", error);
           this.smallModelInitializingPromise = null;
           throw error;
         }
@@ -2981,21 +2501,23 @@ var LocalAIManager = class _LocalAIManager {
     if (this.mediumModelInitialized) return;
     if (!this.mediumModelInitializingPromise) {
       this.mediumModelInitializingPromise = (async () => {
+        await this.initializeEnvironment();
         if (!this.llama) {
           await this.lazyInitSmallModel();
         }
-        await this.downloadModel(ModelType2.TEXT_LARGE);
+        await this.downloadModel(ModelType.TEXT_LARGE);
         try {
           const mediumModel = await this.llama.loadModel({
             gpuLayers: 43,
             modelPath: this.mediumModelPath,
+            // Use the potentially overridden path
             vocabOnly: false
           });
           this.mediumModel = mediumModel;
           this.mediumModelInitialized = true;
-          logger9.info("Medium model initialized successfully");
+          logger8.info("Medium model initialized successfully");
         } catch (error) {
-          logger9.error("Failed to initialize medium model:", error);
+          logger8.error("Failed to initialize medium model:", error);
           this.mediumModelInitializingPromise = null;
           throw error;
         }
@@ -3012,9 +2534,9 @@ var LocalAIManager = class _LocalAIManager {
       this.visionInitializingPromise = (async () => {
         try {
           this.visionInitialized = true;
-          logger9.info("Vision model initialized successfully");
+          logger8.info("Vision model initialized successfully");
         } catch (error) {
-          logger9.error("Failed to initialize vision model:", error);
+          logger8.error("Failed to initialize vision model:", error);
           this.visionInitializingPromise = null;
           throw error;
         }
@@ -3030,10 +2552,24 @@ var LocalAIManager = class _LocalAIManager {
     if (!this.transcriptionInitializingPromise) {
       this.transcriptionInitializingPromise = (async () => {
         try {
+          await this.initializeEnvironment();
+          if (!this.transcribeManager) {
+            this.transcribeManager = TranscribeManager.getInstance(this.cacheDir);
+          }
+          const ffmpegReady = await this.transcribeManager.ensureFFmpeg();
+          if (!ffmpegReady) {
+            logger8.error(
+              "FFmpeg is not available or not configured correctly. Cannot proceed with transcription."
+            );
+            throw new Error(
+              "FFmpeg is required for transcription but is not available. Please see server logs for installation instructions."
+            );
+          }
           this.transcriptionInitialized = true;
-          logger9.info("Transcription model initialized successfully");
+          logger8.info("Transcription prerequisites (FFmpeg) checked and ready.");
+          logger8.info("Transcription model initialized successfully");
         } catch (error) {
-          logger9.error("Failed to initialize transcription model:", error);
+          logger8.error("Failed to initialize transcription model:", error);
           this.transcriptionInitializingPromise = null;
           throw error;
         }
@@ -3049,10 +2585,12 @@ var LocalAIManager = class _LocalAIManager {
     if (!this.ttsInitializingPromise) {
       this.ttsInitializingPromise = (async () => {
         try {
+          await this.initializeEnvironment();
+          this.ttsManager = TTSManager.getInstance(this.cacheDir);
           this.ttsInitialized = true;
-          logger9.info("TTS model initialized successfully");
+          logger8.info("TTS model initialized successfully");
         } catch (error) {
-          logger9.error("Failed to initialize TTS model:", error);
+          logger8.error("Failed to lazy initialize TTS components:", error);
           this.ttsInitializingPromise = null;
           throw error;
         }
@@ -3060,26 +2598,6 @@ var LocalAIManager = class _LocalAIManager {
     }
     await this.ttsInitializingPromise;
   }
-  /**
-   * Lazy initialize the StudioLM integration
-   */
-  async lazyInitStudioLM() {
-    if (this.studioLMInitialized) return;
-    if (!this.studioLMInitializingPromise) {
-      this.studioLMInitializingPromise = (async () => {
-        try {
-          await this.initializeStudioLM();
-          this.studioLMInitialized = true;
-          logger9.info("StudioLM initialized successfully");
-        } catch (error) {
-          logger9.error("Failed to initialize StudioLM:", error);
-          this.studioLMInitializingPromise = null;
-          throw error;
-        }
-      })();
-    }
-    await this.studioLMInitializingPromise;
-  }
 };
 var localAIManager = LocalAIManager.getInstance();
 var localAiPlugin = {
@@ -3087,10 +2605,11 @@ var localAiPlugin = {
   description: "Local AI plugin using LLaMA models",
   async init() {
     try {
-      logger9.debug("Initializing local-ai plugin...");
-      logger9.success("Local AI plugin configuration validated and initialized");
+      logger8.debug("Initializing local-ai plugin environment...");
+      await localAIManager.initializeEnvironment();
+      logger8.success("Local AI plugin configuration validated and initialized");
     } catch (error) {
-      logger9.error("Plugin initialization failed:", {
+      logger8.error("Plugin initialization failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0
       });
@@ -3098,60 +2617,44 @@ var localAiPlugin = {
     }
   },
   models: {
-    [ModelType2.TEXT_SMALL]: async (runtime, { prompt, stopSequences = [] }) => {
+    [ModelType.TEXT_SMALL]: async (runtime, { prompt, stopSequences = [] }) => {
       try {
-        const modelConfig = localAIManager.getTextModelSource();
-        if (modelConfig.source !== "local") {
-          return await localAIManager.generateTextLMStudio({
-            prompt,
-            stopSequences,
-            runtime,
-            modelType: ModelType2.TEXT_SMALL
-          });
-        }
+        await localAIManager.initializeEnvironment();
         return await localAIManager.generateText({
           prompt,
           stopSequences,
           runtime,
-          modelType: ModelType2.TEXT_SMALL
+          modelType: ModelType.TEXT_SMALL
         });
       } catch (error) {
-        logger9.error("Error in TEXT_SMALL handler:", error);
+        logger8.error("Error in TEXT_SMALL handler:", error);
         throw error;
       }
     },
-    [ModelType2.TEXT_LARGE]: async (runtime, { prompt, stopSequences = [] }) => {
+    [ModelType.TEXT_LARGE]: async (runtime, { prompt, stopSequences = [] }) => {
       try {
-        const modelConfig = localAIManager.getTextModelSource();
-        if (modelConfig.source !== "local") {
-          return await localAIManager.generateTextLMStudio({
-            prompt,
-            stopSequences,
-            runtime,
-            modelType: ModelType2.TEXT_LARGE
-          });
-        }
+        await localAIManager.initializeEnvironment();
         return await localAIManager.generateText({
           prompt,
           stopSequences,
           runtime,
-          modelType: ModelType2.TEXT_LARGE
+          modelType: ModelType.TEXT_LARGE
         });
       } catch (error) {
-        logger9.error("Error in TEXT_LARGE handler:", error);
+        logger8.error("Error in TEXT_LARGE handler:", error);
         throw error;
       }
     },
-    [ModelType2.TEXT_EMBEDDING]: async (_runtime, params) => {
+    [ModelType.TEXT_EMBEDDING]: async (_runtime, params) => {
       const text = params?.text;
       try {
         if (!text) {
-          logger9.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);
       } catch (error) {
-        logger9.error("Error in TEXT_EMBEDDING handler:", {
+        logger8.error("Error in TEXT_EMBEDDING handler:", {
           error: error instanceof Error ? error.message : String(error),
           fullText: text,
           textType: typeof text,
@@ -3160,9 +2663,10 @@ var localAiPlugin = {
         return new Array(384).fill(0);
       }
     },
-    [ModelType2.OBJECT_SMALL]: async (runtime, params) => {
+    [ModelType.OBJECT_SMALL]: async (runtime, params) => {
       try {
-        logger9.info("OBJECT_SMALL handler - Processing request:", {
+        await localAIManager.initializeEnvironment();
+        logger8.info("OBJECT_SMALL handler - Processing request:", {
           prompt: params.prompt,
           hasSchema: !!params.schema,
           temperature: params.temperature
@@ -3171,23 +2675,12 @@ var localAiPlugin = {
         if (!jsonPrompt.includes("```json") && !jsonPrompt.includes("respond with valid JSON")) {
           jsonPrompt += "\nPlease respond with valid JSON only, without any explanations, markdown formatting, or additional text.";
         }
-        const modelConfig = localAIManager.getTextModelSource();
-        let textResponse;
-        if (modelConfig.source !== "local") {
-          textResponse = await localAIManager.generateTextLMStudio({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType2.TEXT_SMALL
-          });
-        } else {
-          textResponse = await localAIManager.generateText({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType2.TEXT_SMALL
-          });
-        }
+        const textResponse = await localAIManager.generateText({
+          prompt: jsonPrompt,
+          stopSequences: params.stopSequences,
+          runtime,
+          modelType: ModelType.TEXT_SMALL
+        });
         try {
           const extractJSON = (text) => {
             const jsonBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/;
@@ -3203,17 +2696,17 @@ var localAiPlugin = {
             return text.trim();
           };
           const extractedJsonText = extractJSON(textResponse);
-          logger9.debug("Extracted JSON text:", extractedJsonText);
+          logger8.debug("Extracted JSON text:", extractedJsonText);
           let jsonObject;
           try {
             jsonObject = JSON.parse(extractedJsonText);
           } catch (parseError) {
-            logger9.debug("Initial JSON parse failed, attempting to fix common issues");
+            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) {
-              logger9.error("Failed to parse JSON after fixing:", finalError);
+              logger8.error("Failed to parse JSON after fixing:", finalError);
               throw new Error("Invalid JSON returned from model");
             }
           }
@@ -3225,23 +2718,24 @@ var localAiPlugin = {
                 }
               }
             } catch (schemaError) {
-              logger9.error("Schema validation failed:", schemaError);
+              logger8.error("Schema validation failed:", schemaError);
             }
           }
           return jsonObject;
         } catch (parseError) {
-          logger9.error("Failed to parse JSON:", parseError);
-          logger9.error("Raw response:", textResponse);
+          logger8.error("Failed to parse JSON:", parseError);
+          logger8.error("Raw response:", textResponse);
           throw new Error("Invalid JSON returned from model");
         }
       } catch (error) {
-        logger9.error("Error in OBJECT_SMALL handler:", error);
+        logger8.error("Error in OBJECT_SMALL handler:", error);
         throw error;
       }
     },
-    [ModelType2.OBJECT_LARGE]: async (runtime, params) => {
+    [ModelType.OBJECT_LARGE]: async (runtime, params) => {
       try {
-        logger9.info("OBJECT_LARGE handler - Processing request:", {
+        await localAIManager.initializeEnvironment();
+        logger8.info("OBJECT_LARGE handler - Processing request:", {
           prompt: params.prompt,
           hasSchema: !!params.schema,
           temperature: params.temperature
@@ -3250,23 +2744,12 @@ var localAiPlugin = {
         if (!jsonPrompt.includes("```json") && !jsonPrompt.includes("respond with valid JSON")) {
           jsonPrompt += "\nPlease respond with valid JSON only, without any explanations, markdown formatting, or additional text.";
         }
-        const modelConfig = localAIManager.getTextModelSource();
-        let textResponse;
-        if (modelConfig.source !== "local") {
-          textResponse = await localAIManager.generateTextLMStudio({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType2.TEXT_LARGE
-          });
-        } else {
-          textResponse = await localAIManager.generateText({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType2.TEXT_LARGE
-          });
-        }
+        const textResponse = await localAIManager.generateText({
+          prompt: jsonPrompt,
+          stopSequences: params.stopSequences,
+          runtime,
+          modelType: ModelType.TEXT_LARGE
+        });
         try {
           const extractJSON = (text) => {
             const jsonBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/;
@@ -3286,17 +2769,17 @@ var localAiPlugin = {
           };
           const extractedJsonText = extractJSON(textResponse);
           const cleanedJsonText = cleanupJSON(extractedJsonText);
-          logger9.debug("Extracted JSON text:", cleanedJsonText);
+          logger8.debug("Extracted JSON text:", cleanedJsonText);
           let jsonObject;
           try {
             jsonObject = JSON.parse(cleanedJsonText);
           } catch (parseError) {
-            logger9.debug("Initial JSON parse failed, attempting to fix common issues");
+            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) {
-              logger9.error("Failed to parse JSON after fixing:", finalError);
+              logger8.error("Failed to parse JSON after fixing:", finalError);
               throw new Error("Invalid JSON returned from model");
             }
           }
@@ -3308,43 +2791,43 @@ var localAiPlugin = {
                 }
               }
             } catch (schemaError) {
-              logger9.error("Schema validation failed:", schemaError);
+              logger8.error("Schema validation failed:", schemaError);
             }
           }
           return jsonObject;
         } catch (parseError) {
-          logger9.error("Failed to parse JSON:", parseError);
-          logger9.error("Raw response:", textResponse);
+          logger8.error("Failed to parse JSON:", parseError);
+          logger8.error("Raw response:", textResponse);
           throw new Error("Invalid JSON returned from model");
         }
       } catch (error) {
-        logger9.error("Error in OBJECT_LARGE handler:", error);
+        logger8.error("Error in OBJECT_LARGE handler:", error);
         throw error;
       }
     },
-    [ModelType2.TEXT_TOKENIZER_ENCODE]: async (_runtime, { text }) => {
+    [ModelType.TEXT_TOKENIZER_ENCODE]: async (_runtime, { text }) => {
       try {
         const manager = localAIManager.getTokenizerManager();
         const config = localAIManager.getActiveModelConfig();
         return await manager.encode(text, config);
       } catch (error) {
-        logger9.error("Error in TEXT_TOKENIZER_ENCODE handler:", error);
+        logger8.error("Error in TEXT_TOKENIZER_ENCODE handler:", error);
         throw error;
       }
     },
-    [ModelType2.TEXT_TOKENIZER_DECODE]: async (_runtime, { tokens }) => {
+    [ModelType.TEXT_TOKENIZER_DECODE]: async (_runtime, { tokens }) => {
       try {
         const manager = localAIManager.getTokenizerManager();
         const config = localAIManager.getActiveModelConfig();
         return await manager.decode(tokens, config);
       } catch (error) {
-        logger9.error("Error in TEXT_TOKENIZER_DECODE handler:", error);
+        logger8.error("Error in TEXT_TOKENIZER_DECODE handler:", error);
         throw error;
       }
     },
-    [ModelType2.IMAGE_DESCRIPTION]: async (_runtime, imageUrl) => {
+    [ModelType.IMAGE_DESCRIPTION]: async (_runtime, imageUrl) => {
       try {
-        logger9.info("Processing image from URL:", imageUrl);
+        logger8.info("Processing image from URL:", imageUrl);
         const response = await fetch(imageUrl);
         if (!response.ok) {
           throw new Error(`Failed to fetch image: ${response.statusText}`);
@@ -3353,32 +2836,32 @@ var localAiPlugin = {
         const mimeType = response.headers.get("content-type") || "image/jpeg";
         return await localAIManager.describeImage(buffer, mimeType);
       } catch (error) {
-        logger9.error("Error in IMAGE_DESCRIPTION handler:", {
+        logger8.error("Error in IMAGE_DESCRIPTION handler:", {
           error: error instanceof Error ? error.message : String(error),
           imageUrl
         });
         throw error;
       }
     },
-    [ModelType2.TRANSCRIPTION]: async (_runtime, audioBuffer) => {
+    [ModelType.TRANSCRIPTION]: async (_runtime, audioBuffer) => {
       try {
-        logger9.info("Processing audio transcription:", {
+        logger8.info("Processing audio transcription:", {
           bufferSize: audioBuffer.length
         });
         return await localAIManager.transcribeAudio(audioBuffer);
       } catch (error) {
-        logger9.error("Error in TRANSCRIPTION handler:", {
+        logger8.error("Error in TRANSCRIPTION handler:", {
           error: error instanceof Error ? error.message : String(error),
           bufferSize: audioBuffer.length
         });
         throw error;
       }
     },
-    [ModelType2.TEXT_TO_SPEECH]: async (_runtime, text) => {
+    [ModelType.TEXT_TO_SPEECH]: async (_runtime, text) => {
       try {
         return await localAIManager.generateSpeech(text);
       } catch (error) {
-        logger9.error("Error in TEXT_TO_SPEECH handler:", {
+        logger8.error("Error in TEXT_TO_SPEECH handler:", {
           error: error instanceof Error ? error.message : String(error),
           textLength: text.length
         });
@@ -3394,21 +2877,21 @@ var localAiPlugin = {
           name: "local_ai_test_initialization",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting initialization test");
-              const result = await runtime.useModel(ModelType2.TEXT_SMALL, {
+              logger8.info("Starting initialization test");
+              const result = await runtime.useModel(ModelType.TEXT_SMALL, {
                 prompt: "Debug Mode: Test initialization. Respond with 'Initialization successful' if you can read this.",
                 stopSequences: []
               });
-              logger9.info("Model response:", result);
+              logger8.info("Model response:", result);
               if (!result || typeof result !== "string") {
                 throw new Error("Invalid response from model");
               }
               if (!result.includes("successful")) {
                 throw new Error("Model response does not indicate success");
               }
-              logger9.success("Initialization test completed successfully");
+              logger8.success("Initialization test completed successfully");
             } catch (error) {
-              logger9.error("Initialization test failed:", {
+              logger8.error("Initialization test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });
@@ -3420,21 +2903,21 @@ var localAiPlugin = {
           name: "local_ai_test_text_large",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting TEXT_LARGE model test");
-              const result = await runtime.useModel(ModelType2.TEXT_LARGE, {
+              logger8.info("Starting TEXT_LARGE model test");
+              const result = await runtime.useModel(ModelType.TEXT_LARGE, {
                 prompt: "Debug Mode: Generate a one-sentence response about artificial intelligence.",
                 stopSequences: []
               });
-              logger9.info("Large model response:", result);
+              logger8.info("Large model response:", result);
               if (!result || typeof result !== "string") {
                 throw new Error("Invalid response from large model");
               }
               if (result.length < 10) {
                 throw new Error("Response too short, possible model failure");
               }
-              logger9.success("TEXT_LARGE test completed successfully");
+              logger8.success("TEXT_LARGE test completed successfully");
             } catch (error) {
-              logger9.error("TEXT_LARGE test failed:", {
+              logger8.error("TEXT_LARGE test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });
@@ -3446,11 +2929,11 @@ var localAiPlugin = {
           name: "local_ai_test_text_embedding",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting TEXT_EMBEDDING test");
-              const embedding = await runtime.useModel(ModelType2.TEXT_EMBEDDING, {
+              logger8.info("Starting TEXT_EMBEDDING test");
+              const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
                 text: "This is a test of the text embedding model."
               });
-              logger9.info("Embedding generated with dimensions:", embedding.length);
+              logger8.info("Embedding generated with dimensions:", embedding.length);
               if (!Array.isArray(embedding)) {
                 throw new Error("Embedding is not an array");
               }
@@ -3460,13 +2943,13 @@ var localAiPlugin = {
               if (embedding.some((val) => typeof val !== "number")) {
                 throw new Error("Embedding contains non-numeric values");
               }
-              const nullEmbedding = await runtime.useModel(ModelType2.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");
               }
-              logger9.success("TEXT_EMBEDDING test completed successfully");
+              logger8.success("TEXT_EMBEDDING test completed successfully");
             } catch (error) {
-              logger9.error("TEXT_EMBEDDING test failed:", {
+              logger8.error("TEXT_EMBEDDING test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });
@@ -3478,10 +2961,10 @@ var localAiPlugin = {
           name: "local_ai_test_tokenizer_encode",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting TEXT_TOKENIZER_ENCODE test");
+              logger8.info("Starting TEXT_TOKENIZER_ENCODE test");
               const text = "Hello tokenizer test!";
-              const tokens = await runtime.useModel(ModelType2.TEXT_TOKENIZER_ENCODE, { text });
-              logger9.info("Encoded tokens:", { count: tokens.length });
+              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");
               }
@@ -3491,9 +2974,9 @@ var localAiPlugin = {
               if (tokens.some((token) => !Number.isInteger(token))) {
                 throw new Error("Tokens contain non-integer values");
               }
-              logger9.success("TEXT_TOKENIZER_ENCODE test completed successfully");
+              logger8.success("TEXT_TOKENIZER_ENCODE test completed successfully");
             } catch (error) {
-              logger9.error("TEXT_TOKENIZER_ENCODE test failed:", {
+              logger8.error("TEXT_TOKENIZER_ENCODE test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });
@@ -3505,24 +2988,24 @@ var localAiPlugin = {
           name: "local_ai_test_tokenizer_decode",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting TEXT_TOKENIZER_DECODE test");
+              logger8.info("Starting TEXT_TOKENIZER_DECODE test");
               const originalText = "Hello tokenizer test!";
-              const tokens = await runtime.useModel(ModelType2.TEXT_TOKENIZER_ENCODE, {
+              const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, {
                 text: originalText
               });
-              const decodedText = await runtime.useModel(ModelType2.TEXT_TOKENIZER_DECODE, {
+              const decodedText = await runtime.useModel(ModelType.TEXT_TOKENIZER_DECODE, {
                 tokens
               });
-              logger9.info("Round trip tokenization:", {
+              logger8.info("Round trip tokenization:", {
                 original: originalText,
                 decoded: decodedText
               });
               if (typeof decodedText !== "string") {
                 throw new Error("Decoded output is not a string");
               }
-              logger9.success("TEXT_TOKENIZER_DECODE test completed successfully");
+              logger8.success("TEXT_TOKENIZER_DECODE test completed successfully");
             } catch (error) {
-              logger9.error("TEXT_TOKENIZER_DECODE test failed:", {
+              logger8.error("TEXT_TOKENIZER_DECODE test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });
@@ -3534,10 +3017,10 @@ var localAiPlugin = {
           name: "local_ai_test_image_description",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting IMAGE_DESCRIPTION test");
+              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(ModelType2.IMAGE_DESCRIPTION, imageUrl);
-              logger9.info("Image description result:", result);
+              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");
               }
@@ -3547,9 +3030,9 @@ var localAiPlugin = {
               if (typeof result.title !== "string" || typeof result.description !== "string") {
                 throw new Error("Title or description is not a string");
               }
-              logger9.success("IMAGE_DESCRIPTION test completed successfully");
+              logger8.success("IMAGE_DESCRIPTION test completed successfully");
             } catch (error) {
-              logger9.error("IMAGE_DESCRIPTION test failed:", {
+              logger8.error("IMAGE_DESCRIPTION test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });
@@ -3561,7 +3044,7 @@ var localAiPlugin = {
           name: "local_ai_test_transcription",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting TRANSCRIPTION test");
+              logger8.info("Starting TRANSCRIPTION test");
               const audioData = new Uint8Array([
                 82,
                 73,
@@ -3585,14 +3068,14 @@ var localAiPlugin = {
                 // "fmt "
               ]);
               const audioBuffer = Buffer.from(audioData);
-              const transcription = await runtime.useModel(ModelType2.TRANSCRIPTION, audioBuffer);
-              logger9.info("Transcription result:", transcription);
+              const transcription = await runtime.useModel(ModelType.TRANSCRIPTION, audioBuffer);
+              logger8.info("Transcription result:", transcription);
               if (typeof transcription !== "string") {
                 throw new Error("Transcription result is not a string");
               }
-              logger9.success("TRANSCRIPTION test completed successfully");
+              logger8.success("TRANSCRIPTION test completed successfully");
             } catch (error) {
-              logger9.error("TRANSCRIPTION test failed:", {
+              logger8.error("TRANSCRIPTION test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });
@@ -3604,9 +3087,9 @@ var localAiPlugin = {
           name: "local_ai_test_text_to_speech",
           fn: async (runtime) => {
             try {
-              logger9.info("Starting TEXT_TO_SPEECH test");
+              logger8.info("Starting TEXT_TO_SPEECH test");
               const testText = "This is a test of the text to speech system.";
-              const audioStream = await runtime.useModel(ModelType2.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");
               }
@@ -3624,9 +3107,9 @@ var localAiPlugin = {
                 });
                 audioStream.on("error", reject);
               });
-              logger9.success("TEXT_TO_SPEECH test completed successfully");
+              logger8.success("TEXT_TO_SPEECH test completed successfully");
             } catch (error) {
-              logger9.error("TEXT_TO_SPEECH test failed:", {
+              logger8.error("TEXT_TO_SPEECH test failed:", {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : void 0
               });