@elizaos/plugin-local-ai 1.0.0-beta.7 → 1.0.0-beta.72

package/dist/index.js

@@ -1,75 +1,58 @@
 // src/index.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
-import { Readable as Readable2 } from "node:stream";
-import { fileURLToPath } from "node:url";
-import { ModelType as ModelType3, logger as logger10 } from "@elizaos/core";
-import { EmbeddingModel, FlagEmbedding } from "fastembed";
+import fs5 from "fs";
+import os3 from "os";
+import path5 from "path";
+import { Readable as Readable2 } from "stream";
+import {
+  ModelType,
+  logger as logger8
+} from "@elizaos/core";
 import {
   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),
-  USE_OLLAMA_TEXT_MODELS: z.boolean().default(false),
-  // Ollama Configuration
-  OLLAMA_SERVER_URL: z.string().default("http://localhost:11434"),
-  OLLAMA_MODEL: z.string().default("deepseek-r1-distill-qwen-7b"),
-  USE_OLLAMA_EMBEDDING: z.boolean().default(false),
-  OLLAMA_EMBEDDING_MODEL: z.string().default(""),
-  SMALL_OLLAMA_MODEL: z.string().default("deepseek-r1:1.5b"),
-  MEDIUM_OLLAMA_MODEL: z.string().default("deepseek-r1:7b"),
-  LARGE_OLLAMA_MODEL: z.string().default("deepseek-r1:7b"),
-  // StudioLM Configuration
-  STUDIOLM_SERVER_URL: z.string().default("http://localhost:1234"),
-  STUDIOLM_SMALL_MODEL: z.string().default("lmstudio-community/deepseek-r1-distill-qwen-1.5b"),
-  STUDIOLM_MEDIUM_MODEL: z.string().default("deepseek-r1-distill-qwen-7b"),
-  STUDIOLM_EMBEDDING_MODEL: z.union([z.boolean(), z.string()]).default(false)
+  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,
-    USE_OLLAMA_TEXT_MODELS: config.USE_OLLAMA_TEXT_MODELS
-  });
-  if (!config.USE_LOCAL_AI) {
-    config.USE_LOCAL_AI = true;
-    logger.info("Setting USE_LOCAL_AI to true as it's required");
-  }
-  if (config.USE_STUDIOLM_TEXT_MODELS && config.USE_OLLAMA_TEXT_MODELS) {
-    throw new Error("StudioLM and Ollama text models cannot be enabled simultaneously");
-  }
-  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",
-      USE_OLLAMA_TEXT_MODELS: config.USE_OLLAMA_TEXT_MODELS === "true",
-      USE_OLLAMA_EMBEDDING: config.USE_OLLAMA_EMBEDDING === "true"
-    };
-    validateModelConfig(booleanConfig);
-    const fullConfig = {
-      ...booleanConfig,
-      OLLAMA_SERVER_URL: config.OLLAMA_SERVER_URL || "http://localhost:11434",
-      OLLAMA_MODEL: config.OLLAMA_MODEL || "deepseek-r1-distill-qwen-7b",
-      OLLAMA_EMBEDDING_MODEL: config.OLLAMA_EMBEDDING_MODEL || "",
-      SMALL_OLLAMA_MODEL: config.SMALL_OLLAMA_MODEL || "deepseek-r1:1.5b",
-      MEDIUM_OLLAMA_MODEL: config.MEDIUM_OLLAMA_MODEL || "deepseek-r1:7b",
-      LARGE_OLLAMA_MODEL: config.LARGE_OLLAMA_MODEL || "deepseek-r1:7b",
-      STUDIOLM_SERVER_URL: config.STUDIOLM_SERVER_URL || "http://localhost:1234",
-      STUDIOLM_SMALL_MODEL: config.STUDIOLM_SMALL_MODEL || "lmstudio-community/deepseek-r1-distill-qwen-1.5b",
-      STUDIOLM_MEDIUM_MODEL: config.STUDIOLM_MEDIUM_MODEL || "deepseek-r1-distill-qwen-7b",
-      STUDIOLM_EMBEDDING_MODEL: config.STUDIOLM_EMBEDDING_MODEL || false
+    const 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) {
@@ -110,6 +93,18 @@ var MODEL_SPECS = {
       type: "llama"
     }
   },
+  embedding: {
+    name: "bge-small-en-v1.5.Q4_K_M.gguf",
+    repo: "ChristianAzinn/bge-small-en-v1.5-gguf",
+    size: "133 MB",
+    quantization: "Q4_K_M",
+    contextSize: 512,
+    dimensions: 384,
+    tokenizer: {
+      name: "ChristianAzinn/bge-small-en-v1.5-gguf",
+      type: "llama"
+    }
+  },
   vision: {
     name: "Florence-2-base-ft",
     repo: "onnx-community/Florence-2-base-ft",
@@ -147,86 +142,20 @@ 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"
     }
   }
 };
 
 // src/utils/downloadManager.ts
-import fs from "node:fs";
-import https from "node:https";
-import path from "node:path";
+import fs from "fs";
+import https from "https";
+import path from "path";
 import { logger as logger2 } from "@elizaos/core";
 var DownloadManager = class _DownloadManager {
   static instance = null;
@@ -324,7 +253,10 @@ var DownloadManager = class _DownloadManager {
             reject(new Error(`Failed to download: ${response.statusCode}`));
             return;
           }
-          const totalSize = Number.parseInt(response.headers["content-length"] || "0", 10);
+          const totalSize = Number.parseInt(
+            response.headers["content-length"] || "0",
+            10
+          );
           let downloadedSize = 0;
           let lastLoggedPercent = 0;
           const barLength = 30;
@@ -335,9 +267,13 @@ var DownloadManager = class _DownloadManager {
             downloadedSize += chunk.length;
             const percent = Math.round(downloadedSize / totalSize * 100);
             if (percent >= lastLoggedPercent + 5) {
-              const filledLength = Math.floor(downloadedSize / totalSize * barLength);
+              const filledLength = Math.floor(
+                downloadedSize / totalSize * barLength
+              );
               const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger2.info(`Downloading ${fileName}: ${progressBar} ${percent}%`);
+              logger2.info(
+                `Downloading ${fileName}: ${progressBar} ${percent}%`
+              );
               lastLoggedPercent = percent;
             }
           });
@@ -352,18 +288,24 @@ var DownloadManager = class _DownloadManager {
                   fs.mkdirSync(destDir, { recursive: true });
                 }
                 if (!fs.existsSync(tempPath)) {
-                  reject(new Error(`Temporary file ${tempPath} does not exist`));
+                  reject(
+                    new Error(`Temporary file ${tempPath} does not exist`)
+                  );
                   return;
                 }
                 if (fs.existsSync(destPath)) {
                   try {
                     const backupPath = `${destPath}.bak`;
                     fs.renameSync(destPath, backupPath);
-                    logger2.info(`Created backup of existing file: ${backupPath}`);
+                    logger2.info(
+                      `Created backup of existing file: ${backupPath}`
+                    );
                     fs.renameSync(tempPath, destPath);
                     if (fs.existsSync(backupPath)) {
                       fs.unlinkSync(backupPath);
-                      logger2.info(`Removed backup file after successful update: ${backupPath}`);
+                      logger2.info(
+                        `Removed backup file after successful update: ${backupPath}`
+                      );
                     }
                   } catch (moveErr) {
                     logger2.error(
@@ -373,7 +315,9 @@ var DownloadManager = class _DownloadManager {
                     if (fs.existsSync(backupPath)) {
                       try {
                         fs.renameSync(backupPath, destPath);
-                        logger2.info(`Restored from backup after failed update: ${backupPath}`);
+                        logger2.info(
+                          `Restored from backup after failed update: ${backupPath}`
+                        );
                       } catch (restoreErr) {
                         logger2.error(
                           `Failed to restore from backup: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`
@@ -395,7 +339,9 @@ var DownloadManager = class _DownloadManager {
                 } else {
                   fs.renameSync(tempPath, destPath);
                 }
-                logger2.success(`Download of ${fileName} completed successfully`);
+                logger2.success(
+                  `Download of ${fileName} completed successfully`
+                );
                 this.activeDownloads.delete(destPath);
                 resolve();
               } catch (err) {
@@ -417,7 +363,9 @@ var DownloadManager = class _DownloadManager {
             });
           });
           file.on("error", (err) => {
-            logger2.error(`File write error: ${err instanceof Error ? err.message : String(err)}`);
+            logger2.error(
+              `File write error: ${err instanceof Error ? err.message : String(err)}`
+            );
             file.close(() => {
               if (fs.existsSync(tempPath)) {
                 try {
@@ -435,7 +383,9 @@ var DownloadManager = class _DownloadManager {
         }
       );
       request.on("error", (err) => {
-        logger2.error(`Request error: ${err instanceof Error ? err.message : String(err)}`);
+        logger2.error(
+          `Request error: ${err instanceof Error ? err.message : String(err)}`
+        );
         if (fs.existsSync(tempPath)) {
           try {
             fs.unlinkSync(tempPath);
@@ -474,7 +424,9 @@ var DownloadManager = class _DownloadManager {
    */
   async downloadFile(url, destPath) {
     if (this.activeDownloads.has(destPath)) {
-      logger2.info(`Download for ${destPath} already in progress, waiting for it to complete...`);
+      logger2.info(
+        `Download for ${destPath} already in progress, waiting for it to complete...`
+      );
       const existingDownload = this.activeDownloads.get(destPath);
       if (existingDownload) {
         return existingDownload;
@@ -598,288 +550,11 @@ var DownloadManager = class _DownloadManager {
   }
 };
 
-// src/utils/ollamaManager.ts
-import { ModelType, logger as logger3 } from "@elizaos/core";
-var OllamaManager = class _OllamaManager {
-  static instance = null;
-  serverUrl;
-  initialized = false;
-  availableModels = [];
-  configuredModels = {
-    small: process.env.SMALL_OLLAMA_MODEL || "deepseek-r1:1.5b",
-    medium: process.env.MEDIUM_OLLAMA_MODEL || "deepseek-r1:7b"
-  };
-  /**
-   * Private constructor for initializing OllamaManager.
-   */
-  constructor() {
-    this.serverUrl = process.env.OLLAMA_SERVER_URL || "http://localhost:11434";
-    logger3.info("OllamaManager initialized with configuration:", {
-      serverUrl: this.serverUrl,
-      configuredModels: this.configuredModels,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  /**
-   * Returns an instance of the OllamaManager class.
-   * If an instance does not already exist, a new instance is created and returned.
-   * @returns {OllamaManager} The instance of the OllamaManager class.
-   */
-  static getInstance() {
-    if (!_OllamaManager.instance) {
-      _OllamaManager.instance = new _OllamaManager();
-    }
-    return _OllamaManager.instance;
-  }
-  /**
-   * Asynchronously checks the status of the server by attempting to fetch the "/api/tags" endpoint.
-   * @returns A Promise that resolves to a boolean indicating if the server is reachable and responding with a successful status.
-   */
-  async checkServerStatus() {
-    try {
-      const response = await fetch(`${this.serverUrl}/api/tags`);
-      if (!response.ok) {
-        throw new Error(`Server responded with status: ${response.status}`);
-      }
-      return true;
-    } catch (error) {
-      logger3.error("Ollama server check failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        serverUrl: this.serverUrl,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return false;
-    }
-  }
-  /**
-   * Fetches the available Ollama models from the specified server URL.
-   *
-   * @returns {Promise<void>} A Promise that resolves when the available models are successfully fetched.
-   */
-  async fetchAvailableModels() {
-    try {
-      const response = await fetch(`${this.serverUrl}/api/tags`);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch models: ${response.status}`);
-      }
-      const data = await response.json();
-      this.availableModels = data.models;
-      logger3.info("Ollama available models:", {
-        count: this.availableModels.length,
-        models: this.availableModels.map((m) => m.name),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } catch (error) {
-      logger3.error("Failed to fetch Ollama models:", {
-        error: error instanceof Error ? error.message : String(error),
-        serverUrl: this.serverUrl,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    }
-  }
-  /**
-   * Asynchronously tests a model specified by the given modelId.
-   *
-   * @param {string} modelId - The ID of the model to be tested.
-   * @returns {Promise<boolean>} - A promise that resolves to true if the model test is successful, false otherwise.
-   */
-  async testModel(modelId) {
-    try {
-      const testRequest = {
-        model: modelId,
-        prompt: "Debug Mode: Test initialization. Respond with 'Initialization successful' if you can read this.",
-        stream: false,
-        options: {
-          temperature: 0.7,
-          num_predict: 100
-        }
-      };
-      logger3.info(`Testing model ${modelId}...`);
-      const response = await fetch(`${this.serverUrl}/api/generate`, {
-        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.response) {
-        throw new Error("No valid response content received");
-      }
-      logger3.info(`Model ${modelId} test response:`, {
-        content: result.response,
-        model: result.model,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return true;
-    } catch (error) {
-      logger3.error(`Model ${modelId} test failed:`, {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return false;
-    }
-  }
-  /**
-   * Asynchronously tests the configured text models to ensure they are working properly.
-   * Logs the test results for each model and outputs a warning if any models fail the test.
-   * @returns {Promise<void>} A Promise that resolves when all configured models have been tested.
-   */
-  async testTextModels() {
-    logger3.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");
-      logger3.warn("Some models failed the test:", {
-        failedModels,
-        small: this.configuredModels.small,
-        medium: this.configuredModels.medium
-      });
-    } else {
-      logger3.success("All configured models passed the test");
-    }
-  }
-  /**
-   * Asynchronously initializes the Ollama service by checking server status,
-   * fetching available models, and testing text models.
-   *
-   * @returns A Promise that resolves when initialization is complete
-   */
-  async initialize() {
-    try {
-      if (this.initialized) {
-        logger3.info("Ollama already initialized, skipping initialization");
-        return;
-      }
-      logger3.info("Starting Ollama initialization...");
-      const serverAvailable = await this.checkServerStatus();
-      if (!serverAvailable) {
-        throw new Error("Ollama server is not available");
-      }
-      await this.fetchAvailableModels();
-      await this.testTextModels();
-      this.initialized = true;
-      logger3.success("Ollama initialization complete");
-    } catch (error) {
-      logger3.error("Ollama initialization failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0
-      });
-      throw error;
-    }
-  }
-  /**
-   * Retrieves the available Ollama models.
-   *
-   * @returns {OllamaModel[]} An array of OllamaModel objects representing the available models.
-   */
-  getAvailableModels() {
-    return this.availableModels;
-  }
-  /**
-   * Check if the object is initialized.
-   * @returns {boolean} True if the object is initialized, false otherwise.
-   */
-  isInitialized() {
-    return this.initialized;
-  }
-  /**
-   * Generates text using the Ollama AI model.
-   *
-   * @param {GenerateTextParams} params - The parameters for generating text.
-   * @param {boolean} [isInitialized=false] - Flag indicating if Ollama is already initialized.
-   * @returns {Promise<string>} - A promise that resolves with the generated text.
-   */
-  async generateText(params, isInitialized = false) {
-    try {
-      logger3.info("Ollama 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("Ollama not initialized. Please initialize before generating text.");
-      }
-      logger3.info("Ollama preparing request:", {
-        model: params.modelType === ModelType.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
-        contextLength: params.prompt.length,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      const request = {
-        model: params.modelType === ModelType.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
-        prompt: params.prompt,
-        stream: false,
-        options: {
-          temperature: 0.7,
-          top_p: 0.9,
-          num_predict: 8192,
-          repeat_penalty: 1.2,
-          frequency_penalty: 0.7,
-          presence_penalty: 0.7
-        }
-      };
-      const response = await fetch(`${this.serverUrl}/api/generate`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(request)
-      });
-      if (!response.ok) {
-        throw new Error(`Ollama request failed: ${response.status}`);
-      }
-      const result = await response.json();
-      if (!result.response) {
-        throw new Error("No valid response content received from Ollama");
-      }
-      let responseText = result.response;
-      logger3.info("Raw response structure:", {
-        responseLength: responseText.length,
-        hasAction: responseText.includes("action"),
-        hasThinkTag: responseText.includes("<think>")
-      });
-      if (responseText.includes("<think>")) {
-        logger3.info("Cleaning think tags from response");
-        responseText = responseText.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-        logger3.info("Think tags removed from response");
-      }
-      logger3.info("Ollama request completed successfully:", {
-        responseLength: responseText.length,
-        hasThinkTags: responseText.includes("<think>"),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return responseText;
-    } catch (error) {
-      logger3.error("Ollama text generation error:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        phase: "text generation",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    }
-  }
-};
-
 // src/utils/platform.ts
-import { exec } from "node:child_process";
-import os from "node:os";
-import { promisify } from "node:util";
-import { logger as logger4 } from "@elizaos/core";
+import { exec } from "child_process";
+import os from "os";
+import { promisify } from "util";
+import { logger as logger3 } from "@elizaos/core";
 var execAsync = promisify(exec);
 var PlatformManager = class _PlatformManager {
   static instance;
@@ -906,10 +581,10 @@ var PlatformManager = class _PlatformManager {
    */
   async initialize() {
     try {
-      logger4.info("Initializing platform detection...");
+      logger3.info("Initializing platform detection...");
       this.capabilities = await this.detectSystemCapabilities();
     } catch (error) {
-      logger4.error("Platform detection failed", { error });
+      logger3.error("Platform detection failed", { error });
       throw error;
     }
   }
@@ -971,7 +646,7 @@ var PlatformManager = class _PlatformManager {
           return null;
       }
     } catch (error) {
-      logger4.error("GPU detection failed", { error });
+      logger3.error("GPU detection failed", { error });
       return null;
     }
   }
@@ -990,14 +665,16 @@ var PlatformManager = class _PlatformManager {
           isAppleSilicon: true
         };
       }
-      const { stdout: gpuInfo } = await execAsync("system_profiler SPDisplaysDataType");
+      const { stdout: gpuInfo } = await execAsync(
+        "system_profiler SPDisplaysDataType"
+      );
       return {
         name: gpuInfo.split("Chipset Model:")[1]?.split("\n")[0]?.trim() || "Unknown GPU",
         type: "metal",
         isAppleSilicon: false
       };
     } catch (error) {
-      logger4.error("Mac GPU detection failed", { error });
+      logger3.error("Mac GPU detection failed", { error });
       return {
         name: "Unknown Mac GPU",
         type: "metal",
@@ -1012,7 +689,9 @@ var PlatformManager = class _PlatformManager {
    */
   async detectWindowsGPU() {
     try {
-      const { stdout } = await execAsync("wmic path win32_VideoController get name");
+      const { stdout } = await execAsync(
+        "wmic path win32_VideoController get name"
+      );
       const gpuName = stdout.split("\n")[1].trim();
       if (gpuName.toLowerCase().includes("nvidia")) {
         const { stdout: nvidiaInfo } = await execAsync(
@@ -1032,7 +711,7 @@ var PlatformManager = class _PlatformManager {
         type: "directml"
       };
     } catch (error) {
-      logger4.error("Windows GPU detection failed", { error });
+      logger3.error("Windows GPU detection failed", { error });
       return null;
     }
   }
@@ -1068,7 +747,7 @@ var PlatformManager = class _PlatformManager {
           type: "none"
         };
       } catch (error) {
-        logger4.error("Linux GPU detection failed", { error });
+        logger3.error("Linux GPU detection failed", { error });
         return null;
       }
     }
@@ -1204,298 +883,11 @@ var getPlatformManager = () => {
   return PlatformManager.getInstance();
 };
 
-// src/utils/studiolmManager.ts
-import { ModelType as ModelType2, logger as logger5 } 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";
-    logger5.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) {
-      logger5.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;
-      logger5.info("LM Studio available models:", {
-        count: this.availableModels.length,
-        models: this.availableModels.map((m) => m.id),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } catch (error) {
-      logger5.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
-      };
-      logger5.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");
-      }
-      logger5.info(`Model ${modelId} test response:`, {
-        content: result.choices[0].message.content,
-        model: result.model,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return true;
-    } catch (error) {
-      logger5.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() {
-    logger5.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");
-      logger5.warn("Some models failed the test:", {
-        failedModels,
-        small: this.configuredModels.small,
-        medium: this.configuredModels.medium
-      });
-    } else {
-      logger5.success("All configured models passed the test");
-    }
-  }
-  /**
-   * Initializes StudioLM by checking server status, fetching available models,
-   * and testing text models.
-   *
-   * @returns {Promise<void>} A Promise that resolves when initialization is complete
-   */
-  async initialize() {
-    try {
-      if (this.initialized) {
-        logger5.info("StudioLM already initialized, skipping initialization");
-        return;
-      }
-      logger5.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;
-      logger5.success("StudioLM initialization complete");
-    } catch (error) {
-      logger5.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 {
-      logger5.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 }
-      ];
-      logger5.info("StudioLM preparing request:", {
-        model: params.modelType === ModelType2.TEXT_LARGE ? this.configuredModels.medium : this.configuredModels.small,
-        messageCount: messages.length,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      logger5.info("Incoming context structure:", {
-        contextLength: params.prompt.length,
-        hasAction: params.prompt.includes("action"),
-        runtime: !!params.runtime,
-        stopSequences: params.stopSequences
-      });
-      const request = {
-        model: params.modelType === ModelType2.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;
-      logger5.info("Raw response structure:", {
-        responseLength: responseText.length,
-        hasAction: responseText.includes("action"),
-        hasThinkTag: responseText.includes("<think>")
-      });
-      if (responseText.includes("<think>")) {
-        logger5.info("Cleaning think tags from response");
-        responseText = responseText.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-        logger5.info("Think tags removed from response");
-      }
-      logger5.info("StudioLM request completed successfully:", {
-        responseLength: responseText.length,
-        hasThinkTags: responseText.includes("<think>"),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return responseText;
-    } catch (error) {
-      logger5.error("StudioLM text generation error:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        phase: "text generation",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    }
-  }
-};
-
 // src/utils/tokenizerManager.ts
-import { logger as logger6 } from "@elizaos/core";
-import { AutoTokenizer } from "@huggingface/transformers";
+import { logger as logger4 } from "@elizaos/core";
+import {
+  AutoTokenizer
+} from "@huggingface/transformers";
 var TokenizerManager = class _TokenizerManager {
   static instance = null;
   tokenizers;
@@ -1534,7 +926,7 @@ var TokenizerManager = class _TokenizerManager {
   async loadTokenizer(modelConfig) {
     try {
       const tokenizerKey = `${modelConfig.tokenizer.type}-${modelConfig.tokenizer.name}`;
-      logger6.info("Loading tokenizer:", {
+      logger4.info("Loading tokenizer:", {
         key: tokenizerKey,
         name: modelConfig.tokenizer.name,
         type: modelConfig.tokenizer.type,
@@ -1542,50 +934,61 @@ var TokenizerManager = class _TokenizerManager {
         cacheDir: this.cacheDir
       });
       if (this.tokenizers.has(tokenizerKey)) {
-        logger6.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`);
+          throw new Error(
+            `Tokenizer ${tokenizerKey} exists in map but returned undefined`
+          );
         }
         return cachedTokenizer;
       }
-      const fs6 = await import("node:fs");
+      const fs6 = await import("fs");
       if (!fs6.existsSync(this.modelsDir)) {
-        logger6.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 });
       }
-      logger6.info(
+      logger4.info(
         "Initializing new tokenizer from HuggingFace with models directory:",
         this.modelsDir
       );
       try {
-        const tokenizer = await AutoTokenizer.from_pretrained(modelConfig.tokenizer.name, {
-          cache_dir: this.modelsDir,
-          local_files_only: false
-        });
+        const tokenizer = await AutoTokenizer.from_pretrained(
+          modelConfig.tokenizer.name,
+          {
+            cache_dir: this.modelsDir,
+            local_files_only: false
+          }
+        );
         this.tokenizers.set(tokenizerKey, tokenizer);
-        logger6.success("Tokenizer loaded successfully:", { key: tokenizerKey });
+        logger4.success("Tokenizer loaded successfully:", { key: tokenizerKey });
         return tokenizer;
       } catch (tokenizeError) {
-        logger6.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
         });
-        logger6.info("Retrying tokenizer loading...");
-        const tokenizer = await AutoTokenizer.from_pretrained(modelConfig.tokenizer.name, {
-          cache_dir: this.modelsDir,
-          local_files_only: false
-        });
+        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);
-        logger6.success("Tokenizer loaded successfully on retry:", {
+        logger4.success("Tokenizer loaded successfully on retry:", {
           key: tokenizerKey
         });
         return tokenizer;
       }
     } catch (error) {
-      logger6.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,
@@ -1605,23 +1008,23 @@ var TokenizerManager = class _TokenizerManager {
    */
   async encode(text, modelConfig) {
     try {
-      logger6.info("Encoding text with tokenizer:", {
+      logger4.info("Encoding text with tokenizer:", {
         length: text.length,
         tokenizer: modelConfig.tokenizer.name
       });
       const tokenizer = await this.loadTokenizer(modelConfig);
-      logger6.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
       });
-      logger6.info("Text encoded successfully:", {
+      logger4.info("Text encoded successfully:", {
         tokenCount: encoded.length,
         tokenizer: modelConfig.tokenizer.name
       });
       return encoded;
     } catch (error) {
-      logger6.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,
@@ -1641,23 +1044,23 @@ var TokenizerManager = class _TokenizerManager {
    */
   async decode(tokens, modelConfig) {
     try {
-      logger6.info("Decoding tokens with tokenizer:", {
+      logger4.info("Decoding tokens with tokenizer:", {
         count: tokens.length,
         tokenizer: modelConfig.tokenizer.name
       });
       const tokenizer = await this.loadTokenizer(modelConfig);
-      logger6.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
       });
-      logger6.info("Tokens decoded successfully:", {
+      logger4.info("Tokens decoded successfully:", {
         textLength: decoded.length,
         tokenizer: modelConfig.tokenizer.name
       });
       return decoded;
     } catch (error) {
-      logger6.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,
@@ -1670,11 +1073,11 @@ var TokenizerManager = class _TokenizerManager {
 };
 
 // src/utils/transcribeManager.ts
-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 logger7 } from "@elizaos/core";
+import { exec as exec2 } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+import { promisify as promisify2 } from "util";
+import { logger as logger5 } from "@elizaos/core";
 import { nodewhisper } from "nodejs-whisper";
 var execAsync2 = promisify2(exec2);
 var TranscribeManager = class _TranscribeManager {
@@ -1691,7 +1094,7 @@ var TranscribeManager = class _TranscribeManager {
    */
   constructor(cacheDir) {
     this.cacheDir = path2.join(cacheDir, "whisper");
-    logger7.debug("Initializing TranscribeManager", {
+    logger5.debug("Initializing TranscribeManager", {
       cacheDir: this.cacheDir,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -1707,7 +1110,7 @@ var TranscribeManager = class _TranscribeManager {
         await this.initializeFFmpeg();
         this.ffmpegInitialized = true;
       } catch (error) {
-        logger7.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()
@@ -1745,13 +1148,13 @@ var TranscribeManager = class _TranscribeManager {
     try {
       const { stdout } = await execAsync2("ffmpeg -version");
       this.ffmpegVersion = stdout.split("\n")[0];
-      logger7.info("FFmpeg version:", {
+      logger5.info("FFmpeg version:", {
         version: this.ffmpegVersion,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch (error) {
       this.ffmpegVersion = null;
-      logger7.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()
       });
@@ -1774,12 +1177,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;
-      logger7.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()
@@ -1796,10 +1204,12 @@ var TranscribeManager = class _TranscribeManager {
    */
   async checkFFmpegAvailability() {
     try {
-      const { stdout, stderr } = await execAsync2("which ffmpeg || where ffmpeg");
+      const { stdout, stderr } = await execAsync2(
+        "which ffmpeg || where ffmpeg"
+      );
       this.ffmpegPath = stdout.trim();
       this.ffmpegAvailable = true;
-      logger7.info("FFmpeg found at:", {
+      logger5.info("FFmpeg found at:", {
         path: this.ffmpegPath,
         stderr: stderr ? stderr.trim() : void 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -1807,7 +1217,7 @@ var TranscribeManager = class _TranscribeManager {
     } catch (error) {
       this.ffmpegAvailable = false;
       this.ffmpegPath = null;
-      logger7.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()
@@ -1824,10 +1234,12 @@ var TranscribeManager = class _TranscribeManager {
       const { stdout } = await execAsync2("ffmpeg -codecs");
       const hasRequiredCodecs = stdout.includes("pcm_s16le") && stdout.includes("wav");
       if (!hasRequiredCodecs) {
-        throw new Error("FFmpeg installation missing required codecs (pcm_s16le, wav)");
+        throw new Error(
+          "FFmpeg installation missing required codecs (pcm_s16le, wav)"
+        );
       }
     } catch (error) {
-      logger7.error("FFmpeg capabilities verification failed:", {
+      logger5.error("FFmpeg capabilities verification failed:", {
         error: error instanceof Error ? error.message : String(error),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -1838,17 +1250,20 @@ var TranscribeManager = class _TranscribeManager {
    * Logs instructions on how to install FFmpeg if it is not properly installed.
    */
   logFFmpegInstallInstructions() {
-    logger7.warn("FFmpeg is required but not properly installed. Please install FFmpeg:", {
-      instructions: {
-        mac: "brew install ffmpeg",
-        ubuntu: "sudo apt-get install ffmpeg",
-        windows: "choco install ffmpeg",
-        manual: "Download from https://ffmpeg.org/download.html"
-      },
-      requiredVersion: "4.0 or later",
-      requiredCodecs: ["pcm_s16le", "wav"],
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
+    logger5.warn(
+      "FFmpeg is required but not properly installed. Please install FFmpeg:",
+      {
+        instructions: {
+          mac: "brew install ffmpeg",
+          ubuntu: "sudo apt-get install ffmpeg",
+          windows: "choco install ffmpeg",
+          manual: "Download from https://ffmpeg.org/download.html"
+        },
+        requiredVersion: "4.0 or later",
+        requiredCodecs: ["pcm_s16le", "wav"],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    );
   }
   /**
    * Gets the singleton instance of TranscribeManager, creates a new instance if it doesn't exist.
@@ -1891,7 +1306,7 @@ var TranscribeManager = class _TranscribeManager {
         `ffmpeg -y -loglevel error -i "${inputPath}" -acodec pcm_s16le -ar 16000 -ac 1 "${outputPath}"`
       );
       if (stderr) {
-        logger7.warn("FFmpeg conversion error:", {
+        logger5.warn("FFmpeg conversion error:", {
           stderr,
           inputPath,
           outputPath,
@@ -1902,7 +1317,7 @@ var TranscribeManager = class _TranscribeManager {
         throw new Error("WAV file was not created successfully");
       }
     } catch (error) {
-      logger7.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}"`,
@@ -1926,10 +1341,15 @@ var TranscribeManager = class _TranscribeManager {
    */
   async preprocessAudio(audioBuffer) {
     if (!this.ffmpegAvailable) {
-      throw new Error("FFmpeg is not installed. Please install FFmpeg to use audio transcription.");
+      throw new Error(
+        "FFmpeg is not installed. Please install FFmpeg to use audio transcription."
+      );
     }
     try {
-      const tempInputFile = path2.join(this.cacheDir, `temp_input_${Date.now()}`);
+      const tempInputFile = path2.join(
+        this.cacheDir,
+        `temp_input_${Date.now()}`
+      );
       const tempWavFile = path2.join(this.cacheDir, `temp_${Date.now()}.wav`);
       fs2.writeFileSync(tempInputFile, audioBuffer);
       await this.convertToWav(tempInputFile, tempWavFile);
@@ -1938,7 +1358,7 @@ var TranscribeManager = class _TranscribeManager {
       }
       return tempWavFile;
     } catch (error) {
-      logger7.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,
@@ -1965,7 +1385,7 @@ var TranscribeManager = class _TranscribeManager {
     }
     try {
       const wavFile = await this.preprocessAudio(audioBuffer);
-      logger7.info("Starting transcription with whisper...");
+      logger5.info("Starting transcription with whisper...");
       const originalStdoutWrite = process.stdout.write;
       const originalStderrWrite = process.stderr.write;
       const noopWrite = () => true;
@@ -1988,19 +1408,19 @@ var TranscribeManager = class _TranscribeManager {
       }
       if (fs2.existsSync(wavFile)) {
         fs2.unlinkSync(wavFile);
-        logger7.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(" ");
-      logger7.success("Transcription complete:", {
+      logger5.success("Transcription complete:", {
         textLength: cleanText.length,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return { text: cleanText };
     } catch (error) {
-      logger7.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
@@ -2011,294 +1431,190 @@ var TranscribeManager = class _TranscribeManager {
 };
 
 // src/utils/ttsManager.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
-import { Readable } from "node:stream";
-import { logger as logger8 } from "@elizaos/core";
-import {
-  getLlama
-} from "node-llama-cpp";
-
-// src/utils/audioUtils.ts
-import { PassThrough } from "node:stream";
-function getWavHeader(audioLength, sampleRate, channelCount = 1, bitsPerSample = 16) {
-  const wavHeader = Buffer.alloc(44);
-  wavHeader.write("RIFF", 0);
-  wavHeader.writeUInt32LE(36 + audioLength, 4);
-  wavHeader.write("WAVE", 8);
-  wavHeader.write("fmt ", 12);
-  wavHeader.writeUInt32LE(16, 16);
-  wavHeader.writeUInt16LE(1, 20);
-  wavHeader.writeUInt16LE(channelCount, 22);
-  wavHeader.writeUInt32LE(sampleRate, 24);
-  wavHeader.writeUInt32LE(sampleRate * bitsPerSample * channelCount / 8, 28);
-  wavHeader.writeUInt16LE(bitsPerSample * channelCount / 8, 32);
-  wavHeader.writeUInt16LE(bitsPerSample, 34);
-  wavHeader.write("data", 36);
-  wavHeader.writeUInt32LE(audioLength, 40);
-  return wavHeader;
-}
-function prependWavHeader(readable, audioLength, sampleRate, channelCount = 1, bitsPerSample = 16) {
-  const wavHeader = getWavHeader(audioLength, sampleRate, channelCount, bitsPerSample);
-  let pushedHeader = false;
-  const passThrough = new PassThrough();
-  readable.on("data", (data) => {
-    if (!pushedHeader) {
-      passThrough.push(wavHeader);
-      pushedHeader = true;
-    }
-    passThrough.push(data);
-  });
-  readable.on("end", () => {
-    passThrough.end();
-  });
-  return passThrough;
-}
-
-// src/utils/ttsManager.ts
+import fs3 from "fs";
+import path3 from "path";
+import { Readable } from "stream";
+import { logger as logger6, prependWavHeader } from "@elizaos/core";
+import { pipeline } from "@huggingface/transformers";
+import { fetch as fetch2 } from "undici";
 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();
-    logger8.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 });
-      logger8.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;
-      }
-      logger8.info("Initializing TTS with GGUF backend...");
-      const modelSpec = MODEL_SPECS.tts.base;
-      const modelPath = path3.join(this.modelsDir, modelSpec.name);
-      if (!fs3.existsSync(modelPath)) {
-        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 {
-            logger8.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);
-            logger8.info(`Downloading TTS model: ${emptyBar} 0%`);
-            await this.downloadManager.downloadFromUrl(attempt.url, modelPath);
-            const completedBar = "\u25B0".repeat(barLength);
-            logger8.info(`Downloading TTS model: ${completedBar} 100%`);
-            logger8.success("TTS model download successful with:", attempt.description);
-            break;
-          } catch (error) {
-            lastError = error;
-            logger8.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."
+        );
       }
-      logger8.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();
-      logger8.success("TTS initialization complete", {
-        modelPath,
-        contextSize: modelSpec.contextSize,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      this.initialized = true;
-    } catch (error) {
-      logger8.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");
-      }
-      logger8.info("Starting speech generation for text:", { text });
-      const prompt = `[SPEAKER=female_1][LANGUAGE=en]${text}`;
-      logger8.info("Formatted prompt:", { prompt });
-      logger8.info("Tokenizing input...");
-      const inputTokens = this.model.tokenize(prompt);
-      logger8.info("Input tokenized:", { tokenCount: inputTokens.length });
-      const maxTokens = inputTokens.length * 2;
-      logger8.info("Starting token generation with optimized limit:", {
-        maxTokens
-      });
-      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);
-          logger8.info(
-            `Token generation: ${progressBar} ${percent}% (${responseTokens.length}/${maxTokens})`
-          );
-          if (responseTokens.length >= maxTokens) {
-            logger8.info("Token generation complete");
-            break;
-          }
+      await this.initialize();
+      if (!this.synthesizer) {
+        throw new Error("TTS Manager not properly initialized.");
+      }
+      logger6.info("Starting speech generation with Transformers.js for text:", {
+        text: text.substring(0, 50) + "..."
+      });
+      const output = await this.synthesizer(text, {
+        // Pass embedding only if it was loaded
+        ...this.defaultSpeakerEmbedding && {
+          speaker_embeddings: this.defaultSpeakerEmbedding
         }
-      } catch (error) {
-        logger8.error("Token generation error:", error);
-        throw error;
+      });
+      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;
       }
-      logger8.info("Converting tokens to audio data...");
-      const audioData = this.processAudioResponse({
-        tokens: responseTokens.map((t) => Number.parseInt(this.model.detokenize([t]), 10))
-      });
-      logger8.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
       );
-      logger8.success("Speech generation complete");
+      logger6.success("Speech generation complete (Transformers.js)");
       return audioStream;
     } catch (error) {
-      logger8.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
-import { existsSync } from "node:fs";
-import fs4 from "node:fs";
-import os2 from "node:os";
-import path4 from "node:path";
-import process2 from "node:process";
-import { logger as logger9 } from "@elizaos/core";
+import { existsSync } from "fs";
+import fs4 from "fs";
+import os2 from "os";
+import path4 from "path";
+import process2 from "process";
+import { logger as logger7 } from "@elizaos/core";
 import {
   AutoProcessor,
   AutoTokenizer as AutoTokenizer2,
@@ -2334,9 +1650,12 @@ var VisionManager = class _VisionManager {
     this.modelsDir = path4.join(path4.dirname(cacheDir), "models", "vision");
     this.cacheDir = cacheDir;
     this.ensureModelsDirExists();
-    this.downloadManager = DownloadManager.getInstance(this.cacheDir, this.modelsDir);
+    this.downloadManager = DownloadManager.getInstance(
+      this.cacheDir,
+      this.modelsDir
+    );
     this.platformConfig = this.getPlatformConfig();
-    logger9.debug("VisionManager initialized");
+    logger7.debug("VisionManager initialized");
   }
   /**
    * Retrieves the platform configuration based on the operating system and architecture.
@@ -2373,7 +1692,7 @@ var VisionManager = class _VisionManager {
    */
   ensureModelsDirExists() {
     if (!existsSync(this.modelsDir)) {
-      logger9.debug(`Creating models directory at: ${this.modelsDir}`);
+      logger7.debug(`Creating models directory at: ${this.modelsDir}`);
       fs4.mkdirSync(this.modelsDir, { recursive: true });
     }
   }
@@ -2398,9 +1717,13 @@ var VisionManager = class _VisionManager {
    * @returns {boolean} - Returns true if cache exists, otherwise returns false.
    */
   checkCacheExists(modelId, type) {
-    const modelPath = path4.join(this.modelsDir, modelId.replace("/", "--"), type);
+    const modelPath = path4.join(
+      this.modelsDir,
+      modelId.replace("/", "--"),
+      type
+    );
     if (existsSync(modelPath)) {
-      logger9.info(`${type} found at: ${modelPath}`);
+      logger7.info(`${type} found at: ${modelPath}`);
       return true;
     }
     return false;
@@ -2423,7 +1746,7 @@ var VisionManager = class _VisionManager {
       ...component,
       dtype: defaultDtype
     }));
-    logger9.info("Model components configured with dtype:", {
+    logger7.info("Model components configured with dtype:", {
       platform,
       arch,
       defaultDtype,
@@ -2436,7 +1759,9 @@ var VisionManager = class _VisionManager {
    * @returns {object} The model configuration object containing device, dtype, and cache_dir.
    */
   getModelConfig(componentName) {
-    const component = this.modelComponents.find((c) => c.name === componentName);
+    const component = this.modelComponents.find(
+      (c) => c.name === componentName
+    );
     return {
       device: this.platformConfig.device,
       dtype: component?.dtype || "fp32",
@@ -2452,106 +1777,135 @@ var VisionManager = class _VisionManager {
   async initialize() {
     try {
       if (this.initialized) {
-        logger9.info("Vision model already initialized, skipping initialization");
+        logger7.info(
+          "Vision model already initialized, skipping initialization"
+        );
         return;
       }
-      logger9.info("Starting vision model initialization...");
+      logger7.info("Starting vision model initialization...");
       const modelSpec = MODEL_SPECS.vision;
-      logger9.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";
       }
-      logger9.info("Loading Florence2 model...");
+      logger7.info("Loading Florence2 model...");
       try {
         let lastProgress = -1;
         const modelCached = this.checkCacheExists(modelSpec.modelId, "model");
-        const model = await Florence2ForConditionalGeneration.from_pretrained(modelSpec.modelId, {
-          device: "cpu",
-          cache_dir: this.modelsDir,
-          local_files_only: modelCached,
-          revision: "main",
-          progress_callback: (progressInfo) => {
-            if (modelCached || this.modelDownloaded) return;
-            const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
-            const currentProgress = Math.round(progress * 100);
-            if (currentProgress > lastProgress + 9 || currentProgress === 100) {
-              lastProgress = currentProgress;
-              const barLength = 30;
-              const filledLength = Math.floor(currentProgress / 100 * barLength);
-              const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger9.info(`Downloading vision model: ${progressBar} ${currentProgress}%`);
-              if (currentProgress === 100) this.modelDownloaded = true;
+        const model = await Florence2ForConditionalGeneration.from_pretrained(
+          modelSpec.modelId,
+          {
+            device: "cpu",
+            cache_dir: this.modelsDir,
+            local_files_only: modelCached,
+            revision: "main",
+            progress_callback: (progressInfo) => {
+              if (modelCached || this.modelDownloaded) return;
+              const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
+              const currentProgress = Math.round(progress * 100);
+              if (currentProgress > lastProgress + 9 || currentProgress === 100) {
+                lastProgress = currentProgress;
+                const barLength = 30;
+                const filledLength = Math.floor(
+                  currentProgress / 100 * barLength
+                );
+                const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
+                logger7.info(
+                  `Downloading vision model: ${progressBar} ${currentProgress}%`
+                );
+                if (currentProgress === 100) this.modelDownloaded = true;
+              }
             }
           }
-        });
+        );
         this.model = model;
-        logger9.success("Florence2 model loaded successfully");
+        logger7.success("Florence2 model loaded successfully");
       } catch (error) {
-        logger9.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;
       }
-      logger9.info("Loading vision tokenizer...");
+      logger7.info("Loading vision tokenizer...");
       try {
-        const tokenizerCached = this.checkCacheExists(modelSpec.modelId, "tokenizer");
+        const tokenizerCached = this.checkCacheExists(
+          modelSpec.modelId,
+          "tokenizer"
+        );
         let tokenizerProgress = -1;
-        this.tokenizer = await AutoTokenizer2.from_pretrained(modelSpec.modelId, {
-          cache_dir: this.modelsDir,
-          local_files_only: tokenizerCached,
-          progress_callback: (progressInfo) => {
-            if (tokenizerCached || this.tokenizerDownloaded) return;
-            const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
-            const currentProgress = Math.round(progress * 100);
-            if (currentProgress !== tokenizerProgress) {
-              tokenizerProgress = currentProgress;
-              const barLength = 30;
-              const filledLength = Math.floor(currentProgress / 100 * barLength);
-              const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger9.info(`Downloading vision tokenizer: ${progressBar} ${currentProgress}%`);
-              if (currentProgress === 100) this.tokenizerDownloaded = true;
+        this.tokenizer = await AutoTokenizer2.from_pretrained(
+          modelSpec.modelId,
+          {
+            cache_dir: this.modelsDir,
+            local_files_only: tokenizerCached,
+            progress_callback: (progressInfo) => {
+              if (tokenizerCached || this.tokenizerDownloaded) return;
+              const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
+              const currentProgress = Math.round(progress * 100);
+              if (currentProgress !== tokenizerProgress) {
+                tokenizerProgress = currentProgress;
+                const barLength = 30;
+                const filledLength = Math.floor(
+                  currentProgress / 100 * barLength
+                );
+                const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
+                logger7.info(
+                  `Downloading vision tokenizer: ${progressBar} ${currentProgress}%`
+                );
+                if (currentProgress === 100) this.tokenizerDownloaded = true;
+              }
             }
           }
-        });
-        logger9.success("Vision tokenizer loaded successfully");
+        );
+        logger7.success("Vision tokenizer loaded successfully");
       } catch (error) {
-        logger9.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;
       }
-      logger9.info("Loading vision processor...");
+      logger7.info("Loading vision processor...");
       try {
-        const processorCached = this.checkCacheExists(modelSpec.modelId, "processor");
+        const processorCached = this.checkCacheExists(
+          modelSpec.modelId,
+          "processor"
+        );
         let processorProgress = -1;
-        this.processor = await AutoProcessor.from_pretrained(modelSpec.modelId, {
-          device: "cpu",
-          cache_dir: this.modelsDir,
-          local_files_only: processorCached,
-          progress_callback: (progressInfo) => {
-            if (processorCached || this.processorDownloaded) return;
-            const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
-            const currentProgress = Math.round(progress * 100);
-            if (currentProgress !== processorProgress) {
-              processorProgress = currentProgress;
-              const barLength = 30;
-              const filledLength = Math.floor(currentProgress / 100 * barLength);
-              const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
-              logger9.info(`Downloading vision processor: ${progressBar} ${currentProgress}%`);
-              if (currentProgress === 100) this.processorDownloaded = true;
+        this.processor = await AutoProcessor.from_pretrained(
+          modelSpec.modelId,
+          {
+            device: "cpu",
+            cache_dir: this.modelsDir,
+            local_files_only: processorCached,
+            progress_callback: (progressInfo) => {
+              if (processorCached || this.processorDownloaded) return;
+              const progress = "progress" in progressInfo ? Math.max(0, Math.min(1, progressInfo.progress)) : 0;
+              const currentProgress = Math.round(progress * 100);
+              if (currentProgress !== processorProgress) {
+                processorProgress = currentProgress;
+                const barLength = 30;
+                const filledLength = Math.floor(
+                  currentProgress / 100 * barLength
+                );
+                const progressBar = "\u25B0".repeat(filledLength) + "\u25B1".repeat(barLength - filledLength);
+                logger7.info(
+                  `Downloading vision processor: ${progressBar} ${currentProgress}%`
+                );
+                if (currentProgress === 100) this.processorDownloaded = true;
+              }
             }
           }
-        });
-        logger9.success("Vision processor loaded successfully");
+        );
+        logger7.success("Vision processor loaded successfully");
       } catch (error) {
-        logger9.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
@@ -2559,9 +1913,9 @@ var VisionManager = class _VisionManager {
         throw error;
       }
       this.initialized = true;
-      logger9.success("Vision model initialization complete");
+      logger7.success("Vision model initialization complete");
     } catch (error) {
-      logger9.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
@@ -2577,13 +1931,13 @@ var VisionManager = class _VisionManager {
    */
   async fetchImage(url) {
     try {
-      logger9.info(`Fetching image from URL: ${url.slice(0, 100)}...`);
+      logger7.info(`Fetching image from URL: ${url.slice(0, 100)}...`);
       if (url.startsWith("data:")) {
-        logger9.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");
-        logger9.info("Data URL processed successfully");
+        logger7.info("Data URL processed successfully");
         return { buffer: buffer2, mimeType: mimeType2 };
       }
       const response = await fetch(url);
@@ -2592,14 +1946,14 @@ var VisionManager = class _VisionManager {
       }
       const buffer = Buffer.from(await response.arrayBuffer());
       const mimeType = response.headers.get("content-type") || "image/jpeg";
-      logger9.info("Image fetched successfully:", {
+      logger7.info("Image fetched successfully:", {
         mimeType,
         bufferSize: buffer.length,
         status: response.status
       });
       return { buffer, mimeType };
     } catch (error) {
-      logger9.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
@@ -2614,37 +1968,37 @@ var VisionManager = class _VisionManager {
    */
   async processImage(imageUrl) {
     try {
-      logger9.info("Starting image processing...");
+      logger7.info("Starting image processing...");
       if (!this.initialized) {
-        logger9.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");
       }
-      logger9.info("Fetching image...");
+      logger7.info("Fetching image...");
       const { buffer, mimeType } = await this.fetchImage(imageUrl);
-      logger9.info("Creating image blob...");
+      logger7.info("Creating image blob...");
       const blob = new Blob([buffer], { type: mimeType });
-      logger9.info("Converting blob to RawImage...");
+      logger7.info("Converting blob to RawImage...");
       const image = await RawImage.fromBlob(blob);
-      logger9.info("Processing image with vision processor...");
+      logger7.info("Processing image with vision processor...");
       const visionInputs = await this.processor(image);
-      logger9.info("Constructing prompts...");
+      logger7.info("Constructing prompts...");
       const prompts = this.processor.construct_prompts("<DETAILED_CAPTION>");
-      logger9.info("Tokenizing prompts...");
+      logger7.info("Tokenizing prompts...");
       const textInputs = this.tokenizer(prompts);
-      logger9.info("Generating image description...");
+      logger7.info("Generating image description...");
       const generatedIds = await this.model.generate({
         ...textInputs,
         ...visionInputs,
         max_new_tokens: MODEL_SPECS.vision.maxTokens
       });
-      logger9.info("Decoding generated text...");
+      logger7.info("Decoding generated text...");
       const generatedText = this.tokenizer.batch_decode(generatedIds, {
         skip_special_tokens: false
       })[0];
-      logger9.info("Post-processing generation...");
+      logger7.info("Post-processing generation...");
       const result = this.processor.post_process_generation(
         generatedText,
         "<DETAILED_CAPTION>",
@@ -2655,13 +2009,13 @@ var VisionManager = class _VisionManager {
         title: `${detailedCaption.split(".")[0]}.`,
         description: detailedCaption
       };
-      logger9.success("Image processing complete:", {
+      logger7.success("Image processing complete:", {
         titleLength: response.title.length,
         descriptionLength: response.description.length
       });
       return response;
     } catch (error) {
-      logger9.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,
@@ -2676,8 +2030,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",
@@ -2733,30 +2086,33 @@ var LocalAIManager = class _LocalAIManager {
   llama;
   smallModel;
   mediumModel;
+  embeddingModel;
+  embeddingContext;
   ctx;
   sequence;
   chatSession;
   modelPath;
   mediumModelPath;
+  embeddingModelPath;
   cacheDir;
-  embeddingModel = null;
   tokenizerManager;
   downloadManager;
   visionManager;
   activeModelConfig;
+  embeddingModelConfig;
   transcribeManager;
   ttsManager;
-  studioLMManager;
-  ollamaManager;
-  // Initialization state flags
-  ollamaInitialized = false;
-  studioLMInitialized = false;
+  config = null;
+  // Store validated config
+  // Initialization state flag
   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;
@@ -2764,49 +2120,96 @@ var LocalAIManager = class _LocalAIManager {
   visionInitializingPromise = null;
   transcriptionInitializingPromise = null;
   ttsInitializingPromise = null;
-  ollamaInitializingPromise = 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(process.cwd(), "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 });
-        logger10.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");
-    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(process.cwd(), "cache");
+      const cacheDir = path5.join(os3.homedir(), ".eliza", "cache");
       if (!fs5.existsSync(cacheDir)) {
         fs5.mkdirSync(cacheDir, { recursive: true });
-        logger10.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 (process.env.USE_OLLAMA_TEXT_MODELS === "true") {
-      this.ollamaManager = OllamaManager.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;
   }
   /**
    * Retrieves the singleton instance of LocalAIManager. If an instance does not already exist, a new one is created and returned.
@@ -2819,99 +2222,86 @@ 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 {
-      logger10.info("Validating environment configuration...");
-      const config = {
-        USE_LOCAL_AI: process.env.USE_LOCAL_AI,
-        USE_STUDIOLM_TEXT_MODELS: process.env.USE_STUDIOLM_TEXT_MODELS,
-        USE_OLLAMA_TEXT_MODELS: process.env.USE_OLLAMA_TEXT_MODELS
-      };
-      const validatedConfig = await validateConfig(config);
-      logger10.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);
-      process.env.USE_OLLAMA_TEXT_MODELS = String(validatedConfig.USE_OLLAMA_TEXT_MODELS);
-      logger10.success("Environment initialization complete");
-    } catch (error) {
-      logger10.error("Environment validation failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0
-      });
-      throw error;
-    }
-  }
-  /**
-   * Asynchronously initializes the Ollama model.
-   *
-   * @returns {Promise<void>} A Promise that resolves when the initialization is complete.
-   * @throws {Error} If the Ollama manager is not created, or if initialization of Ollama models fails.
-   */
-  async initializeOllama() {
-    try {
-      logger10.info("Initializing Ollama models...");
-      if (!this.ollamaManager) {
-        throw new Error("Ollama manager not created - cannot initialize");
-      }
-      await this.ollamaManager.initialize();
-      if (!this.ollamaManager.isInitialized()) {
-        throw new Error("Ollama initialization failed - models not properly loaded");
-      }
-      logger10.success("Ollama initialization complete");
-    } catch (error) {
-      logger10.error("Ollama 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;
+    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 {
-      logger10.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;
-      logger10.success("StudioLM initialization complete");
-    } catch (error) {
-      logger10.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.
-   * Determines whether to download a large or small model based on the current modelPath.
+   * Determines the model spec and path based on the model type.
    *
+   * @param {ModelTypeName} modelType - The type of model to download
+   * @param {ModelSpec} [customModelSpec] - Optional custom model spec to use instead of the default
    * @returns A Promise that resolves to a boolean indicating whether the model download was successful.
    */
-  async downloadModel(modelType) {
-    const modelSpec = modelType === ModelType3.TEXT_LARGE ? MODEL_SPECS.medium : MODEL_SPECS.small;
-    const modelPath = modelType === ModelType3.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
+  async downloadModel(modelType, customModelSpec) {
+    let modelSpec;
+    let modelPathToDownload;
+    await this.initializeEnvironment();
+    if (customModelSpec) {
+      modelSpec = customModelSpec;
+      modelPathToDownload = modelType === ModelType.TEXT_EMBEDDING ? this.embeddingModelPath : modelType === ModelType.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
+    } else if (modelType === ModelType.TEXT_EMBEDDING) {
+      modelSpec = MODEL_SPECS.embedding;
+      modelPathToDownload = this.embeddingModelPath;
+    } else {
+      modelSpec = modelType === ModelType.TEXT_LARGE ? MODEL_SPECS.medium : MODEL_SPECS.small;
+      modelPathToDownload = modelType === ModelType.TEXT_LARGE ? this.mediumModelPath : this.modelPath;
+    }
     try {
-      return await this.downloadManager.downloadModel(modelSpec, modelPath);
+      return await this.downloadManager.downloadModel(
+        modelSpec,
+        modelPathToDownload
+      );
     } catch (error) {
-      logger10.error("Model download failed:", {
+      logger8.error("Model download failed:", {
         error: error instanceof Error ? error.message : String(error),
-        modelPath
+        modelType,
+        modelPath: modelPathToDownload
       });
       throw error;
     }
@@ -2926,14 +2316,14 @@ var LocalAIManager = class _LocalAIManager {
       const platformManager = getPlatformManager();
       await platformManager.initialize();
       const capabilities = platformManager.getCapabilities();
-      logger10.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) {
-      logger10.warn("Platform detection failed:", error);
+      logger8.warn("Platform detection failed:", error);
     }
   }
   /**
@@ -2942,8 +2332,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 = ModelType3.TEXT_SMALL) {
-    if (modelType === ModelType3.TEXT_LARGE) {
+  async initialize(modelType = ModelType.TEXT_SMALL) {
+    await this.initializeEnvironment();
+    if (modelType === ModelType.TEXT_LARGE) {
       await this.lazyInitMediumModel();
     } else {
       await this.lazyInitSmallModel();
@@ -2956,96 +2347,120 @@ var LocalAIManager = class _LocalAIManager {
    */
   async initializeEmbedding() {
     try {
-      logger10.info("Initializing embedding model...");
-      logger10.info("Models directory:", this.modelsDir);
+      await this.initializeEnvironment();
+      logger8.info("Initializing embedding model...");
+      logger8.info("Models directory:", this.modelsDir);
       if (!fs5.existsSync(this.modelsDir)) {
-        logger10.warn("Models directory does not exist, creating it:", this.modelsDir);
+        logger8.warn(
+          "Models directory does not exist, creating it:",
+          this.modelsDir
+        );
         fs5.mkdirSync(this.modelsDir, { recursive: true });
       }
+      await this.downloadModel(ModelType.TEXT_EMBEDDING);
+      if (!this.llama) {
+        this.llama = await getLlama();
+      }
       if (!this.embeddingModel) {
-        logger10.info("Creating new FlagEmbedding instance with BGESmallENV15 model");
-        const barLength = 30;
-        const emptyBar = "\u25B1".repeat(barLength);
-        logger10.info(`Downloading embedding model: ${emptyBar} 0%`);
-        this.embeddingModel = await FlagEmbedding.init({
-          cacheDir: this.modelsDir,
-          model: EmbeddingModel.BGESmallENV15,
-          maxLength: 512,
-          showDownloadProgress: false
+        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
+        });
+        this.embeddingContext = await this.embeddingModel.createEmbeddingContext({
+          contextSize: this.embeddingModelConfig.contextSize,
+          batchSize: 512
         });
-        const completedBar = "\u25B0".repeat(barLength);
-        logger10.info(`Downloading embedding model: ${completedBar} 100%`);
-        logger10.success("FlagEmbedding instance created successfully");
+        logger8.success("Embedding model initialized successfully");
       }
     } catch (error) {
-      logger10.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,
-        model: EmbeddingModel.BGESmallENV15
+        embeddingModelPath: this.embeddingModelPath
+        // Log the path being used
       });
       throw error;
     }
   }
   /**
-   * Asynchronously generates text using either StudioLM or Ollama models based on the specified parameters.
-   *
-   * @param {GenerateTextParams} params - The parameters for generating the text.
-   * @returns {Promise<string>} - A promise that resolves to the generated text.
+   * Generate embeddings using the proper LlamaContext.getEmbedding method.
    */
-  async generateTextOllamaStudio(params) {
+  async generateEmbedding(text) {
     try {
-      const modelConfig = this.getTextModelSource();
-      logger10.info("generateTextOllamaStudio called with:", {
-        modelSource: modelConfig.source,
-        modelType: params.modelType,
-        studioLMInitialized: this.studioLMInitialized,
-        ollamaInitialized: this.ollamaInitialized,
-        studioLMEnabled: process.env.USE_STUDIOLM_TEXT_MODELS === "true",
-        ollamaEnabled: process.env.USE_OLLAMA_TEXT_MODELS === "true"
-      });
-      if (modelConfig.source === "studiolm") {
-        if (process.env.USE_STUDIOLM_TEXT_MODELS !== "true") {
-          logger10.warn(
-            "StudioLM requested but disabled in environment, falling back to local models"
-          );
-          return this.generateText(params);
-        }
-        if (!this.studioLMManager) {
-          logger10.warn("StudioLM manager not initialized, falling back to local models");
-          return this.generateText(params);
-        }
-        if (!this.studioLMInitialized) {
-          logger10.info("StudioLM not initialized, initializing now...");
-          await this.initializeStudioLM();
-        }
-        return await this.studioLMManager.generateText(params, this.studioLMInitialized);
-      }
-      if (modelConfig.source === "ollama") {
-        if (process.env.USE_OLLAMA_TEXT_MODELS !== "true") {
-          logger10.warn("Ollama requested but disabled in environment, falling back to local models");
-          return this.generateText(params);
-        }
-        if (!this.ollamaManager) {
-          logger10.warn("Ollama manager not initialized, falling back to local models");
-          return this.generateText(params);
-        }
-        if (!this.ollamaInitialized && !this.ollamaManager.isInitialized()) {
-          logger10.info("Initializing Ollama in generateTextOllamaStudio");
-          await this.ollamaManager.initialize();
-          this.ollamaInitialized = true;
-        }
-        return await this.ollamaManager.generateText(params, this.ollamaInitialized);
+      await this.lazyInitEmbedding();
+      if (!this.embeddingModel || !this.embeddingContext) {
+        throw new Error("Failed to initialize embedding model");
       }
-      return this.generateText(params);
+      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);
+      logger8.info("Embedding generation complete", {
+        dimensions: normalizedEmbedding.length
+      });
+      return normalizedEmbedding;
     } catch (error) {
-      logger10.error("Text generation with Ollama/StudioLM failed:", {
+      logger8.error("Embedding generation failed:", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
-        modelSource: this.getTextModelSource().source
+        textLength: text?.length ?? "text is null"
       });
-      return this.generateText(params);
+      const zeroDimensions = this.config?.LOCAL_EMBEDDING_DIMENSIONS ? this.config.LOCAL_EMBEDDING_DIMENSIONS : this.embeddingModelConfig.dimensions;
+      return new Array(zeroDimensions).fill(0);
+    }
+  }
+  /**
+   * Normalizes an embedding vector using L2 normalization
+   *
+   * @param {number[]} embedding - The embedding vector to normalize
+   * @returns {number[]} - The normalized embedding vector
+   */
+  normalizeEmbedding(embedding) {
+    const squareSum = embedding.reduce((sum, val) => sum + val * val, 0);
+    const norm = Math.sqrt(squareSum);
+    if (norm === 0) {
+      return embedding;
+    }
+    return embedding.map((val) => val / norm);
+  }
+  /**
+   * Lazy initialize the embedding model
+   */
+  async lazyInitEmbedding() {
+    if (this.embeddingInitialized) return;
+    if (!this.embeddingInitializingPromise) {
+      this.embeddingInitializingPromise = (async () => {
+        try {
+          await this.initializeEnvironment();
+          await this.downloadModel(ModelType.TEXT_EMBEDDING);
+          if (!this.llama) {
+            this.llama = await getLlama();
+          }
+          this.embeddingModel = await this.llama.loadModel({
+            modelPath: this.embeddingModelPath,
+            gpuLayers: 0,
+            // Embedding models are typically small enough to run on CPU
+            vocabOnly: false
+          });
+          this.embeddingContext = await this.embeddingModel.createEmbeddingContext({
+            contextSize: this.embeddingModelConfig.contextSize,
+            batchSize: 512
+          });
+          this.embeddingInitialized = true;
+          logger8.info("Embedding model initialized successfully");
+        } catch (error) {
+          logger8.error("Failed to initialize embedding model:", error);
+          this.embeddingInitializingPromise = null;
+          throw error;
+        }
+      })();
     }
+    await this.embeddingInitializingPromise;
   }
   /**
    * Asynchronously generates text based on the provided parameters.
@@ -3053,7 +2468,9 @@ var LocalAIManager = class _LocalAIManager {
    */
   async generateText(params) {
     try {
-      if (params.modelType === ModelType3.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");
@@ -3084,15 +2501,18 @@ var LocalAIManager = class _LocalAIManager {
       if (!this.chatSession) {
         throw new Error("Failed to create chat session");
       }
-      logger10.info("Created new chat session for model:", params.modelType);
-      logger10.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);
-      logger10.info("Input tokens:", { count: tokens.length });
+      const tokens = await this.tokenizerManager.encode(
+        params.prompt,
+        this.activeModelConfig
+      );
+      logger8.info("Input tokens:", { count: tokens.length });
       const systemMessage = "You are a helpful AI assistant. Respond to the current request only.";
       await this.chatSession.prompt(systemMessage, {
         maxTokens: 1,
@@ -3104,49 +2524,25 @@ var LocalAIManager = class _LocalAIManager {
         temperature: 0.7,
         topP: 0.9,
         repeatPenalty: {
-          punishTokensFilter: () => this.smallModel.tokenize(wordsToPunish.join(" ")),
+          punishTokensFilter: () => this.smallModel ? this.smallModel.tokenize(wordsToPunish.join(" ")) : [],
           penalty: 1.2,
           frequencyPenalty: 0.7,
           presencePenalty: 0.7
         }
       });
-      logger10.info("Raw response structure:", {
+      logger8.info("Raw response structure:", {
         responseLength: response.length,
         hasAction: response.includes("action"),
         hasThinkTag: response.includes("<think>")
       });
       if (response.includes("<think>")) {
-        logger10.info("Cleaning think tags from response");
+        logger8.info("Cleaning think tags from response");
         response = response.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-        logger10.info("Think tags removed from response");
+        logger8.info("Think tags removed from response");
       }
       return response;
     } catch (error) {
-      logger10.error("Text generation failed:", error);
-      throw error;
-    }
-  }
-  /**
-   * Generate embeddings - now with lazy initialization
-   */
-  async generateEmbedding(text) {
-    try {
-      await this.lazyInitEmbedding();
-      if (!this.embeddingModel) {
-        throw new Error("Failed to initialize embedding model");
-      }
-      logger10.info("Generating query embedding...");
-      const embedding = await this.embeddingModel.queryEmbed(text);
-      const dimensions = embedding.length;
-      logger10.info("Embedding generation complete", { dimensions });
-      return Array.from(embedding);
-    } catch (error) {
-      logger10.error("Embedding generation failed:", {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0,
-        // Only access text.length if text exists
-        textLength: text?.length ?? "text is null"
-      });
+      logger8.error("Text generation failed:", error);
       throw error;
     }
   }
@@ -3160,7 +2556,7 @@ var LocalAIManager = class _LocalAIManager {
       const dataUrl = `data:${mimeType};base64,${base64}`;
       return await this.visionManager.processImage(dataUrl);
     } catch (error) {
-      logger10.error("Image description failed:", error);
+      logger8.error("Image description failed:", error);
       throw error;
     }
   }
@@ -3173,7 +2569,7 @@ var LocalAIManager = class _LocalAIManager {
       const result = await this.transcribeManager.transcribe(audioBuffer);
       return result.text;
     } catch (error) {
-      logger10.error("Audio transcription failed:", {
+      logger8.error("Audio transcription failed:", {
         error: error instanceof Error ? error.message : String(error),
         bufferSize: audioBuffer.length
       });
@@ -3188,14 +2584,13 @@ var LocalAIManager = class _LocalAIManager {
       await this.lazyInitTTS();
       return await this.ttsManager.generateSpeech(text);
     } catch (error) {
-      logger10.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.
    *
@@ -3211,43 +2606,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: ModelType3.TEXT_SMALL
-      };
-      if (process.env.USE_STUDIOLM_TEXT_MODELS === "true" && this.studioLMManager) {
-        config.source = "studiolm";
-      } else if (process.env.USE_OLLAMA_TEXT_MODELS === "true" && this.ollamaManager) {
-        config.source = "ollama";
-      }
-      logger10.info("Selected text model source:", config);
-      return config;
-    } catch (error) {
-      logger10.error("Error determining text model source:", error);
-      return { source: "local", modelType: ModelType3.TEXT_SMALL };
-    }
-  }
-  /**
-   * Generic lazy initialization handler for any model type
-   */
-  async lazyInitialize(modelType, isInitialized, initPromise, initFunction) {
-    if (isInitialized) {
-      return Promise.resolve(null);
-    }
-    if (initPromise) {
-      logger10.info(`Waiting for ${modelType} initialization to complete...`);
-      await initPromise;
-      return Promise.resolve(null);
-    }
-    logger10.info(`Lazy initializing ${modelType}...`);
-    return initFunction();
-  }
   /**
    * Lazy initialize the small text model
    */
@@ -3257,12 +2615,13 @@ var LocalAIManager = class _LocalAIManager {
       this.smallModelInitializingPromise = (async () => {
         await this.initializeEnvironment();
         await this.checkPlatformCapabilities();
-        await this.downloadModel(ModelType3.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;
@@ -3272,9 +2631,9 @@ var LocalAIManager = class _LocalAIManager {
           this.ctx = ctx;
           this.sequence = void 0;
           this.smallModelInitialized = true;
-          logger10.info("Small model initialized successfully");
+          logger8.info("Small model initialized successfully");
         } catch (error) {
-          logger10.error("Failed to initialize small model:", error);
+          logger8.error("Failed to initialize small model:", error);
           this.smallModelInitializingPromise = null;
           throw error;
         }
@@ -3289,21 +2648,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(ModelType3.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;
-          logger10.info("Medium model initialized successfully");
+          logger8.info("Medium model initialized successfully");
         } catch (error) {
-          logger10.error("Failed to initialize medium model:", error);
+          logger8.error("Failed to initialize medium model:", error);
           this.mediumModelInitializingPromise = null;
           throw error;
         }
@@ -3311,26 +2672,6 @@ var LocalAIManager = class _LocalAIManager {
     }
     await this.mediumModelInitializingPromise;
   }
-  /**
-   * Lazy initialize the embedding model
-   */
-  async lazyInitEmbedding() {
-    if (this.embeddingInitialized) return;
-    if (!this.embeddingInitializingPromise) {
-      this.embeddingInitializingPromise = (async () => {
-        try {
-          await this.initializeEmbedding();
-          this.embeddingInitialized = true;
-          logger10.info("Embedding model initialized successfully");
-        } catch (error) {
-          logger10.error("Failed to initialize embedding model:", error);
-          this.embeddingInitializingPromise = null;
-          throw error;
-        }
-      })();
-    }
-    await this.embeddingInitializingPromise;
-  }
   /**
    * Lazy initialize the vision model
    */
@@ -3340,9 +2681,9 @@ var LocalAIManager = class _LocalAIManager {
       this.visionInitializingPromise = (async () => {
         try {
           this.visionInitialized = true;
-          logger10.info("Vision model initialized successfully");
+          logger8.info("Vision model initialized successfully");
         } catch (error) {
-          logger10.error("Failed to initialize vision model:", error);
+          logger8.error("Failed to initialize vision model:", error);
           this.visionInitializingPromise = null;
           throw error;
         }
@@ -3358,10 +2699,28 @@ 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;
-          logger10.info("Transcription model initialized successfully");
+          logger8.info(
+            "Transcription prerequisites (FFmpeg) checked and ready."
+          );
+          logger8.info("Transcription model initialized successfully");
         } catch (error) {
-          logger10.error("Failed to initialize transcription model:", error);
+          logger8.error("Failed to initialize transcription model:", error);
           this.transcriptionInitializingPromise = null;
           throw error;
         }
@@ -3377,10 +2736,12 @@ var LocalAIManager = class _LocalAIManager {
     if (!this.ttsInitializingPromise) {
       this.ttsInitializingPromise = (async () => {
         try {
+          await this.initializeEnvironment();
+          this.ttsManager = TTSManager.getInstance(this.cacheDir);
           this.ttsInitialized = true;
-          logger10.info("TTS model initialized successfully");
+          logger8.info("TTS model initialized successfully");
         } catch (error) {
-          logger10.error("Failed to initialize TTS model:", error);
+          logger8.error("Failed to lazy initialize TTS components:", error);
           this.ttsInitializingPromise = null;
           throw error;
         }
@@ -3388,57 +2749,18 @@ var LocalAIManager = class _LocalAIManager {
     }
     await this.ttsInitializingPromise;
   }
-  /**
-   * Lazy initialize the Ollama integration
-   */
-  async lazyInitOllama() {
-    if (this.ollamaInitialized) return;
-    if (!this.ollamaInitializingPromise) {
-      this.ollamaInitializingPromise = (async () => {
-        try {
-          await this.initializeOllama();
-          this.ollamaInitialized = true;
-          logger10.info("Ollama initialized successfully");
-        } catch (error) {
-          logger10.error("Failed to initialize Ollama:", error);
-          this.ollamaInitializingPromise = null;
-          throw error;
-        }
-      })();
-    }
-    await this.ollamaInitializingPromise;
-  }
-  /**
-   * Lazy initialize the StudioLM integration
-   */
-  async lazyInitStudioLM() {
-    if (this.studioLMInitialized) return;
-    if (!this.studioLMInitializingPromise) {
-      this.studioLMInitializingPromise = (async () => {
-        try {
-          await this.initializeStudioLM();
-          this.studioLMInitialized = true;
-          logger10.info("StudioLM initialized successfully");
-        } catch (error) {
-          logger10.error("Failed to initialize StudioLM:", error);
-          this.studioLMInitializingPromise = null;
-          throw error;
-        }
-      })();
-    }
-    await this.studioLMInitializingPromise;
-  }
 };
 var localAIManager = LocalAIManager.getInstance();
-var localAIPlugin = {
+var localAiPlugin = {
   name: "local-ai",
   description: "Local AI plugin using LLaMA models",
   async init() {
     try {
-      logger10.debug("Initializing local-ai plugin...");
-      logger10.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) {
-      logger10.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
       });
@@ -3446,60 +2768,46 @@ var localAIPlugin = {
     }
   },
   models: {
-    [ModelType3.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.generateTextOllamaStudio({
-            prompt,
-            stopSequences,
-            runtime,
-            modelType: ModelType3.TEXT_SMALL
-          });
-        }
+        await localAIManager.initializeEnvironment();
         return await localAIManager.generateText({
           prompt,
           stopSequences,
           runtime,
-          modelType: ModelType3.TEXT_SMALL
+          modelType: ModelType.TEXT_SMALL
         });
       } catch (error) {
-        logger10.error("Error in TEXT_SMALL handler:", error);
+        logger8.error("Error in TEXT_SMALL handler:", error);
         throw error;
       }
     },
-    [ModelType3.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.generateTextOllamaStudio({
-            prompt,
-            stopSequences,
-            runtime,
-            modelType: ModelType3.TEXT_LARGE
-          });
-        }
+        await localAIManager.initializeEnvironment();
         return await localAIManager.generateText({
           prompt,
           stopSequences,
           runtime,
-          modelType: ModelType3.TEXT_LARGE
+          modelType: ModelType.TEXT_LARGE
         });
       } catch (error) {
-        logger10.error("Error in TEXT_LARGE handler:", error);
+        logger8.error("Error in TEXT_LARGE handler:", error);
         throw error;
       }
     },
-    [ModelType3.TEXT_EMBEDDING]: async (_runtime, params) => {
+    [ModelType.TEXT_EMBEDDING]: async (_runtime, params) => {
       const text = params?.text;
       try {
         if (!text) {
-          logger10.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) {
-        logger10.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,
@@ -3508,9 +2816,10 @@ var localAIPlugin = {
         return new Array(384).fill(0);
       }
     },
-    [ModelType3.OBJECT_SMALL]: async (runtime, params) => {
+    [ModelType.OBJECT_SMALL]: async (runtime, params) => {
       try {
-        logger10.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
@@ -3519,23 +2828,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.generateTextOllamaStudio({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType3.TEXT_SMALL
-          });
-        } else {
-          textResponse = await localAIManager.generateText({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType3.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*```/;
@@ -3551,17 +2849,22 @@ var localAIPlugin = {
             return text.trim();
           };
           const extractedJsonText = extractJSON(textResponse);
-          logger10.debug("Extracted JSON text:", extractedJsonText);
+          logger8.debug("Extracted JSON text:", extractedJsonText);
           let jsonObject;
           try {
             jsonObject = JSON.parse(extractedJsonText);
           } catch (parseError) {
-            logger10.debug("Initial JSON parse failed, attempting to fix common issues");
-            const fixedJson = extractedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(/"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g, '"$1$2"').replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
+            logger8.debug(
+              "Initial JSON parse failed, attempting to fix common issues"
+            );
+            const fixedJson = extractedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(
+              /"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g,
+              '"$1$2"'
+            ).replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
             try {
               jsonObject = JSON.parse(fixedJson);
             } catch (finalError) {
-              logger10.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");
             }
           }
@@ -3573,23 +2876,24 @@ var localAIPlugin = {
                 }
               }
             } catch (schemaError) {
-              logger10.error("Schema validation failed:", schemaError);
+              logger8.error("Schema validation failed:", schemaError);
             }
           }
           return jsonObject;
         } catch (parseError) {
-          logger10.error("Failed to parse JSON:", parseError);
-          logger10.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) {
-        logger10.error("Error in OBJECT_SMALL handler:", error);
+        logger8.error("Error in OBJECT_SMALL handler:", error);
         throw error;
       }
     },
-    [ModelType3.OBJECT_LARGE]: async (runtime, params) => {
+    [ModelType.OBJECT_LARGE]: async (runtime, params) => {
       try {
-        logger10.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
@@ -3598,23 +2902,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.generateTextOllamaStudio({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType3.TEXT_LARGE
-          });
-        } else {
-          textResponse = await localAIManager.generateText({
-            prompt: jsonPrompt,
-            stopSequences: params.stopSequences,
-            runtime,
-            modelType: ModelType3.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*```/;
@@ -3634,17 +2927,22 @@ var localAIPlugin = {
           };
           const extractedJsonText = extractJSON(textResponse);
           const cleanedJsonText = cleanupJSON(extractedJsonText);
-          logger10.debug("Extracted JSON text:", cleanedJsonText);
+          logger8.debug("Extracted JSON text:", cleanedJsonText);
           let jsonObject;
           try {
             jsonObject = JSON.parse(cleanedJsonText);
           } catch (parseError) {
-            logger10.debug("Initial JSON parse failed, attempting to fix common issues");
-            const fixedJson = cleanedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(/"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g, '"$1$2"').replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
+            logger8.debug(
+              "Initial JSON parse failed, attempting to fix common issues"
+            );
+            const fixedJson = cleanedJsonText.replace(/:\s*"([^"]*)(?:\n)([^"]*)"/g, ': "$1\\n$2"').replace(
+              /"([^"]*?)[^a-zA-Z0-9\s\.,;:\-_\(\)"'\[\]{}]([^"]*?)"/g,
+              '"$1$2"'
+            ).replace(/(\s*)(\w+)(\s*):/g, '$1"$2"$3:').replace(/,(\s*[\]}])/g, "$1");
             try {
               jsonObject = JSON.parse(fixedJson);
             } catch (finalError) {
-              logger10.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");
             }
           }
@@ -3656,43 +2954,43 @@ var localAIPlugin = {
                 }
               }
             } catch (schemaError) {
-              logger10.error("Schema validation failed:", schemaError);
+              logger8.error("Schema validation failed:", schemaError);
             }
           }
           return jsonObject;
         } catch (parseError) {
-          logger10.error("Failed to parse JSON:", parseError);
-          logger10.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) {
-        logger10.error("Error in OBJECT_LARGE handler:", error);
+        logger8.error("Error in OBJECT_LARGE handler:", error);
         throw error;
       }
     },
-    [ModelType3.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) {
-        logger10.error("Error in TEXT_TOKENIZER_ENCODE handler:", error);
+        logger8.error("Error in TEXT_TOKENIZER_ENCODE handler:", error);
         throw error;
       }
     },
-    [ModelType3.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) {
-        logger10.error("Error in TEXT_TOKENIZER_DECODE handler:", error);
+        logger8.error("Error in TEXT_TOKENIZER_DECODE handler:", error);
         throw error;
       }
     },
-    [ModelType3.IMAGE_DESCRIPTION]: async (_runtime, imageUrl) => {
+    [ModelType.IMAGE_DESCRIPTION]: async (_runtime, imageUrl) => {
       try {
-        logger10.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}`);
@@ -3701,32 +2999,32 @@ var localAIPlugin = {
         const mimeType = response.headers.get("content-type") || "image/jpeg";
         return await localAIManager.describeImage(buffer, mimeType);
       } catch (error) {
-        logger10.error("Error in IMAGE_DESCRIPTION handler:", {
+        logger8.error("Error in IMAGE_DESCRIPTION handler:", {
           error: error instanceof Error ? error.message : String(error),
           imageUrl
         });
         throw error;
       }
     },
-    [ModelType3.TRANSCRIPTION]: async (_runtime, audioBuffer) => {
+    [ModelType.TRANSCRIPTION]: async (_runtime, audioBuffer) => {
       try {
-        logger10.info("Processing audio transcription:", {
+        logger8.info("Processing audio transcription:", {
           bufferSize: audioBuffer.length
         });
         return await localAIManager.transcribeAudio(audioBuffer);
       } catch (error) {
-        logger10.error("Error in TRANSCRIPTION handler:", {
+        logger8.error("Error in TRANSCRIPTION handler:", {
           error: error instanceof Error ? error.message : String(error),
           bufferSize: audioBuffer.length
         });
         throw error;
       }
     },
-    [ModelType3.TEXT_TO_SPEECH]: async (_runtime, text) => {
+    [ModelType.TEXT_TO_SPEECH]: async (_runtime, text) => {
       try {
         return await localAIManager.generateSpeech(text);
       } catch (error) {
-        logger10.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
         });
@@ -3742,21 +3040,21 @@ var localAIPlugin = {
           name: "local_ai_test_initialization",
           fn: async (runtime) => {
             try {
-              logger10.info("Starting initialization test");
-              const result = await runtime.useModel(ModelType3.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: []
               });
-              logger10.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");
               }
-              logger10.success("Initialization test completed successfully");
+              logger8.success("Initialization test completed successfully");
             } catch (error) {
-              logger10.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
               });
@@ -3768,21 +3066,21 @@ var localAIPlugin = {
           name: "local_ai_test_text_large",
           fn: async (runtime) => {
             try {
-              logger10.info("Starting TEXT_LARGE model test");
-              const result = await runtime.useModel(ModelType3.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: []
               });
-              logger10.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");
               }
-              logger10.success("TEXT_LARGE test completed successfully");
+              logger8.success("TEXT_LARGE test completed successfully");
             } catch (error) {
-              logger10.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
               });
@@ -3794,11 +3092,17 @@ var localAIPlugin = {
           name: "local_ai_test_text_embedding",
           fn: async (runtime) => {
             try {
-              logger10.info("Starting TEXT_EMBEDDING test");
-              const embedding = await runtime.useModel(ModelType3.TEXT_EMBEDDING, {
-                text: "This is a test of the text embedding model."
-              });
-              logger10.info("Embedding generated with dimensions:", embedding.length);
+              logger8.info("Starting TEXT_EMBEDDING test");
+              const embedding = await runtime.useModel(
+                ModelType.TEXT_EMBEDDING,
+                {
+                  text: "This is a test of the text embedding model."
+                }
+              );
+              logger8.info(
+                "Embedding generated with dimensions:",
+                embedding.length
+              );
               if (!Array.isArray(embedding)) {
                 throw new Error("Embedding is not an array");
               }
@@ -3808,13 +3112,16 @@ var localAIPlugin = {
               if (embedding.some((val) => typeof val !== "number")) {
                 throw new Error("Embedding contains non-numeric values");
               }
-              const nullEmbedding = await runtime.useModel(ModelType3.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");
               }
-              logger10.success("TEXT_EMBEDDING test completed successfully");
+              logger8.success("TEXT_EMBEDDING test completed successfully");
             } catch (error) {
-              logger10.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
               });
@@ -3826,10 +3133,13 @@ var localAIPlugin = {
           name: "local_ai_test_tokenizer_encode",
           fn: async (runtime) => {
             try {
-              logger10.info("Starting TEXT_TOKENIZER_ENCODE test");
+              logger8.info("Starting TEXT_TOKENIZER_ENCODE test");
               const text = "Hello tokenizer test!";
-              const tokens = await runtime.useModel(ModelType3.TEXT_TOKENIZER_ENCODE, { text });
-              logger10.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");
               }
@@ -3839,9 +3149,11 @@ var localAIPlugin = {
               if (tokens.some((token) => !Number.isInteger(token))) {
                 throw new Error("Tokens contain non-integer values");
               }
-              logger10.success("TEXT_TOKENIZER_ENCODE test completed successfully");
+              logger8.success(
+                "TEXT_TOKENIZER_ENCODE test completed successfully"
+              );
             } catch (error) {
-              logger10.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
               });
@@ -3853,24 +3165,32 @@ var localAIPlugin = {
           name: "local_ai_test_tokenizer_decode",
           fn: async (runtime) => {
             try {
-              logger10.info("Starting TEXT_TOKENIZER_DECODE test");
+              logger8.info("Starting TEXT_TOKENIZER_DECODE test");
               const originalText = "Hello tokenizer test!";
-              const tokens = await runtime.useModel(ModelType3.TEXT_TOKENIZER_ENCODE, {
-                text: originalText
-              });
-              const decodedText = await runtime.useModel(ModelType3.TEXT_TOKENIZER_DECODE, {
-                tokens
-              });
-              logger10.info("Round trip tokenization:", {
+              const tokens = await runtime.useModel(
+                ModelType.TEXT_TOKENIZER_ENCODE,
+                {
+                  text: originalText
+                }
+              );
+              const decodedText = await runtime.useModel(
+                ModelType.TEXT_TOKENIZER_DECODE,
+                {
+                  tokens
+                }
+              );
+              logger8.info("Round trip tokenization:", {
                 original: originalText,
                 decoded: decodedText
               });
               if (typeof decodedText !== "string") {
                 throw new Error("Decoded output is not a string");
               }
-              logger10.success("TEXT_TOKENIZER_DECODE test completed successfully");
+              logger8.success(
+                "TEXT_TOKENIZER_DECODE test completed successfully"
+              );
             } catch (error) {
-              logger10.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
               });
@@ -3882,10 +3202,13 @@ var localAIPlugin = {
           name: "local_ai_test_image_description",
           fn: async (runtime) => {
             try {
-              logger10.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(ModelType3.IMAGE_DESCRIPTION, imageUrl);
-              logger10.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");
               }
@@ -3895,9 +3218,9 @@ var localAIPlugin = {
               if (typeof result.title !== "string" || typeof result.description !== "string") {
                 throw new Error("Title or description is not a string");
               }
-              logger10.success("IMAGE_DESCRIPTION test completed successfully");
+              logger8.success("IMAGE_DESCRIPTION test completed successfully");
             } catch (error) {
-              logger10.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
               });
@@ -3909,7 +3232,7 @@ var localAIPlugin = {
           name: "local_ai_test_transcription",
           fn: async (runtime) => {
             try {
-              logger10.info("Starting TRANSCRIPTION test");
+              logger8.info("Starting TRANSCRIPTION test");
               const audioData = new Uint8Array([
                 82,
                 73,
@@ -3933,14 +3256,17 @@ var localAIPlugin = {
                 // "fmt "
               ]);
               const audioBuffer = Buffer.from(audioData);
-              const transcription = await runtime.useModel(ModelType3.TRANSCRIPTION, audioBuffer);
-              logger10.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");
               }
-              logger10.success("TRANSCRIPTION test completed successfully");
+              logger8.success("TRANSCRIPTION test completed successfully");
             } catch (error) {
-              logger10.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
               });
@@ -3952,9 +3278,12 @@ var localAIPlugin = {
           name: "local_ai_test_text_to_speech",
           fn: async (runtime) => {
             try {
-              logger10.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(ModelType3.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");
               }
@@ -3972,9 +3301,9 @@ var localAIPlugin = {
                 });
                 audioStream.on("error", reject);
               });
-              logger10.success("TEXT_TO_SPEECH test completed successfully");
+              logger8.success("TEXT_TO_SPEECH test completed successfully");
             } catch (error) {
-              logger10.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
               });
@@ -3986,9 +3315,9 @@ var localAIPlugin = {
     }
   ]
 };
-var index_default = localAIPlugin;
+var index_default = localAiPlugin;
 export {
   index_default as default,
-  localAIPlugin
+  localAiPlugin
 };
 //# sourceMappingURL=index.js.map