@elizaos/plugin-local-ai 2.0.0-alpha.6 → 2.0.0-beta.1

package/dist/node/index.node.js

@@ -1,20 +1,4 @@
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // index.ts
@@ -22,11 +6,7 @@ import fs5 from "node:fs";
 import os3 from "node:os";
 import path5, { basename } from "node:path";
 import { Readable as Readable2 } from "node:stream";
-import {
-  logger as logger8,
-  ModelType,
-  parseKeyValueXml
-} from "@elizaos/core";
+import { EventType, logger as logger8, ModelType } from "@elizaos/core";
 import {
   getLlama,
   LlamaChatSession
@@ -35,16 +15,16 @@ import {
 // 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 DEFAULT_SMALL_MODEL = "text/eliza-1-mobile-1_7b-32k.gguf";
+var DEFAULT_LARGE_MODEL = "text/eliza-1-desktop-9b-64k.gguf";
+var DEFAULT_EMBEDDING_MODEL = "text/eliza-1-lite-0_6b-32k.gguf";
 var configSchema = z.object({
   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(),
   CACHE_DIR: z.string().optional(),
-  LOCAL_EMBEDDING_DIMENSIONS: z.string().optional().default("384").transform((val) => parseInt(val, 10))
+  LOCAL_EMBEDDING_DIMENSIONS: z.string().optional().default("1024").transform((val) => parseInt(val, 10))
 });
 function validateConfig() {
   try {
@@ -56,67 +36,135 @@ function validateConfig() {
       CACHE_DIR: process.env.CACHE_DIR,
       LOCAL_EMBEDDING_DIMENSIONS: process.env.LOCAL_EMBEDDING_DIMENSIONS
     };
-    logger.debug("Validating configuration for local AI plugin from env:", {
+    logger.debug({
       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
-    });
+    }, "Validating configuration for local AI plugin from env:");
     const validatedConfig = configSchema.parse(configToParse);
-    logger.info("Using local AI configuration:", validatedConfig);
+    logger.info(validatedConfig, "Using local AI configuration:");
     return validatedConfig;
   } catch (error) {
     if (error instanceof z.ZodError) {
-      const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join(`
+      const errorMessages = error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(`
 `);
-      logger.error("Zod validation failed:", errorMessages);
+      logger.error(`Zod validation failed: ${errorMessages}`);
       throw new Error(`Configuration validation failed:
 ${errorMessages}`);
     }
-    logger.error("Configuration validation failed:", {
+    logger.error({
       error: error instanceof Error ? error.message : String(error),
       stack: error instanceof Error ? error.stack : undefined
-    });
+    }, "Configuration validation failed:");
     throw error;
   }
 }
 
+// structured-output.ts
+import {
+  defineChatSessionFunction,
+  LlamaGrammar,
+  LlamaJsonSchemaGrammar
+} from "node-llama-cpp";
+function toGbnfJsonSchema(schema) {
+  if (schema == null)
+    return;
+  if (typeof schema !== "object") {
+    throw new Error("[plugin-local-ai] JSON schema must be an object");
+  }
+  return schema;
+}
+function buildLlamaFunctions(tools) {
+  const out = {};
+  for (const tool of tools) {
+    if (!tool?.name)
+      continue;
+    out[tool.name] = defineChatSessionFunction({
+      description: tool.description,
+      params: toGbnfJsonSchema(tool.parameters),
+      handler: () => "[deferred to runtime]"
+    });
+  }
+  return out;
+}
+function extractToolCalls(response) {
+  const calls = [];
+  let i = 0;
+  for (const entry of response) {
+    if (entry && typeof entry === "object" && entry.type === "functionCall") {
+      const fc = entry;
+      calls.push({
+        id: `call_${i++}`,
+        name: fc.name,
+        arguments: fc.params ?? {},
+        type: "function"
+      });
+    }
+  }
+  return calls;
+}
+function buildJsonSchemaGrammar(llama, schema) {
+  const gbnf = toGbnfJsonSchema(schema);
+  if (gbnf == null) {
+    throw new Error("[plugin-local-ai] responseSchema is required to build a JSON schema grammar");
+  }
+  return new LlamaJsonSchemaGrammar(llama, gbnf);
+}
+async function buildGenericJsonGrammar(llama) {
+  return await LlamaGrammar.getFor(llama, "json");
+}
+async function planStructuredRequest(ctx, params) {
+  if (params.tools && params.tools.length > 0) {
+    return { kind: "tools", functions: buildLlamaFunctions(params.tools) };
+  }
+  if (params.responseSchema) {
+    const grammar = buildJsonSchemaGrammar(ctx.llama, params.responseSchema);
+    return { kind: "schema", grammar };
+  }
+  if (params.responseFormat && typeof params.responseFormat === "object" && params.responseFormat.type === "json_object") {
+    const grammar = await buildGenericJsonGrammar(ctx.llama);
+    return { kind: "json_object", grammar };
+  }
+  return { kind: "text" };
+}
+
 // types.ts
 var MODEL_SPECS = {
   small: {
-    name: "DeepHermes-3-Llama-3-3B-Preview-q4.gguf",
-    repo: "NousResearch/DeepHermes-3-Llama-3-3B-Preview-GGUF",
-    size: "3B",
-    quantization: "Q4_0",
-    contextSize: 8192,
+    name: "text/eliza-1-mobile-1_7b-32k.gguf",
+    repo: "elizaos/eliza-1-mobile-1_7b",
+    size: "1.7B",
+    quantization: "fused GGUF",
+    contextSize: 32768,
     tokenizer: {
-      name: "NousResearch/DeepHermes-3-Llama-3-3B-Preview",
-      type: "llama"
+      name: "elizaos/eliza-1-mobile-1_7b",
+      type: "eliza1"
     }
   },
   medium: {
-    name: "DeepHermes-3-Llama-3-8B-q4.gguf",
-    repo: "NousResearch/DeepHermes-3-Llama-3-8B-Preview-GGUF",
-    size: "8B",
-    quantization: "Q4_0",
-    contextSize: 8192,
+    name: "text/eliza-1-desktop-9b-64k.gguf",
+    repo: "elizaos/eliza-1-desktop-9b",
+    size: "9B",
+    quantization: "fused GGUF",
+    contextSize: 65536,
     tokenizer: {
-      name: "NousResearch/DeepHermes-3-Llama-3-8B-Preview",
-      type: "llama"
+      name: "elizaos/eliza-1-desktop-9b",
+      type: "eliza1"
     }
   },
   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,
+    name: "text/eliza-1-lite-0_6b-32k.gguf",
+    repo: "elizaos/eliza-1-lite-0_6b",
+    size: "512 MB",
+    quantization: "fused GGUF",
+    contextSize: 32768,
+    dimensions: 1024,
     tokenizer: {
-      name: "ChristianAzinn/bge-small-en-v1.5-gguf",
-      type: "llama"
+      name: "elizaos/eliza-1-lite-0_6b",
+      type: "eliza1"
     }
   },
   vision: {
@@ -139,12 +187,12 @@ var MODEL_SPECS = {
     ]
   },
   visionvl: {
-    name: "Qwen2.5-VL-3B-Instruct",
-    repo: "Qwen/Qwen2.5-VL-3B-Instruct",
-    size: "3B",
-    modelId: "Qwen/Qwen2.5-VL-3B-Instruct",
-    contextSize: 32768,
-    maxTokens: 1024,
+    name: "Florence-2-base-ft",
+    repo: "onnx-community/Florence-2-base-ft",
+    size: "0.23B",
+    modelId: "onnx-community/Florence-2-base-ft",
+    contextSize: 1024,
+    maxTokens: 256,
     tasks: [
       "CAPTION",
       "DETAILED_CAPTION",
@@ -188,7 +236,7 @@ class DownloadManager {
     return DownloadManager.instance;
   }
   ensureCacheDirectory() {
-    if (!this.cacheDir || this.cacheDir.trim() === "") {
+    if (this.cacheDir.trim() === "") {
       throw new Error("Cache directory path cannot be empty");
     }
     if (!fs.existsSync(this.cacheDir)) {
@@ -197,7 +245,7 @@ class DownloadManager {
     }
   }
   ensureModelsDirectory() {
-    if (!this.modelsDir || this.modelsDir.trim() === "") {
+    if (this.modelsDir.trim() === "") {
       throw new Error("Models directory path cannot be empty");
     }
     logger2.debug("Ensuring models directory exists:", this.modelsDir);
@@ -484,7 +532,7 @@ class PlatformManager {
       logger3.info("Initializing platform detection...");
       this.capabilities = await this.detectSystemCapabilities();
     } catch (error) {
-      logger3.error("Platform detection failed", { error });
+      logger3.error({ error }, "Platform detection failed");
       throw error;
     }
   }
@@ -531,7 +579,7 @@ class PlatformManager {
           return null;
       }
     } catch (error) {
-      logger3.error("GPU detection failed", { error });
+      logger3.error({ error }, "GPU detection failed");
       return null;
     }
   }
@@ -554,7 +602,7 @@ class PlatformManager {
         isAppleSilicon: false
       };
     } catch (error) {
-      logger3.error("Mac GPU detection failed", { error });
+      logger3.error({ error }, "Mac GPU detection failed");
       return {
         name: "Unknown Mac GPU",
         type: "metal",
@@ -562,28 +610,49 @@ class PlatformManager {
       };
     }
   }
-  async detectWindowsGPU() {
+  async queryWindowsGpuName() {
+    const psCmd = "powershell -NoProfile -NonInteractive -Command " + '"Get-CimInstance Win32_VideoController | Select-Object -ExpandProperty Name"';
+    try {
+      const { stdout } = await execAsync(psCmd);
+      const first = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)[0];
+      if (first)
+        return first;
+    } catch {}
     try {
       const { stdout } = await execAsync("wmic path win32_VideoController get name");
-      const gpuName = stdout.split(`
-`)[1].trim();
+      const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && line.toLowerCase() !== "name");
+      return lines[0] ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async detectWindowsGPU() {
+    try {
+      const gpuName = await this.queryWindowsGpuName();
+      if (!gpuName)
+        return null;
       if (gpuName.toLowerCase().includes("nvidia")) {
-        const { stdout: nvidiaInfo } = await execAsync("nvidia-smi --query-gpu=name,memory.total --format=csv,noheader");
-        const [name, memoryStr] = nvidiaInfo.split(",").map((s) => s.trim());
-        const memory = Number.parseInt(memoryStr, 10);
-        return {
-          name,
-          memory,
-          type: "cuda",
-          version: await this.getNvidiaDriverVersion()
-        };
+        try {
+          const { stdout: nvidiaInfo } = await execAsync("nvidia-smi --query-gpu=name,memory.total --format=csv,noheader");
+          const firstLine = nvidiaInfo.split(/\r?\n/)[0] ?? "";
+          const [name, memoryStr] = firstLine.split(",").map((s) => s.trim());
+          const memory = Number.parseInt(memoryStr, 10);
+          return {
+            name: name || gpuName,
+            memory: Number.isFinite(memory) ? memory : undefined,
+            type: "cuda",
+            version: await this.getNvidiaDriverVersion()
+          };
+        } catch {
+          return { name: gpuName, type: "cuda" };
+        }
       }
       return {
         name: gpuName,
         type: "directml"
       };
     } catch (error) {
-      logger3.error("Windows GPU detection failed", { error });
+      logger3.error({ error }, "Windows GPU detection failed");
       return null;
     }
   }
@@ -608,7 +677,7 @@ class PlatformManager {
           type: "none"
         };
       } catch (error) {
-        logger3.error("Linux GPU detection failed", { error });
+        logger3.error({ error }, "Linux GPU detection failed");
         return null;
       }
     }
@@ -721,15 +790,15 @@ class TokenizerManager {
   async loadTokenizer(modelConfig) {
     try {
       const tokenizerKey = `${modelConfig.tokenizer.type}-${modelConfig.tokenizer.name}`;
-      logger4.info("Loading tokenizer:", {
+      logger4.info({
         key: tokenizerKey,
         name: modelConfig.tokenizer.name,
         type: modelConfig.tokenizer.type,
         modelsDir: this.modelsDir,
         cacheDir: this.cacheDir
-      });
+      }, "Loading tokenizer:");
       if (this.tokenizers.has(tokenizerKey)) {
-        logger4.info("Using cached tokenizer:", { key: tokenizerKey });
+        logger4.info({ key: tokenizerKey }, "Using cached tokenizer:");
         const cachedTokenizer = this.tokenizers.get(tokenizerKey);
         if (!cachedTokenizer) {
           throw new Error(`Tokenizer ${tokenizerKey} exists in map but returned undefined`);
@@ -748,90 +817,88 @@ class TokenizerManager {
           local_files_only: false
         });
         this.tokenizers.set(tokenizerKey, tokenizer);
-        logger4.success("Tokenizer loaded successfully:", { key: tokenizerKey });
+        logger4.success({ key: tokenizerKey }, "Tokenizer loaded successfully:");
         return tokenizer;
       } catch (tokenizeError) {
-        logger4.error("Failed to load tokenizer from HuggingFace:", {
+        logger4.error({
           error: tokenizeError instanceof Error ? tokenizeError.message : String(tokenizeError),
           stack: tokenizeError instanceof Error ? tokenizeError.stack : undefined,
           tokenizer: modelConfig.tokenizer.name,
           modelsDir: this.modelsDir
-        });
+        }, "Failed to load tokenizer from HuggingFace:");
         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);
-        logger4.success("Tokenizer loaded successfully on retry:", {
-          key: tokenizerKey
-        });
+        logger4.success({ key: tokenizerKey }, "Tokenizer loaded successfully on retry:");
         return tokenizer;
       }
     } catch (error) {
-      logger4.error("Failed to load tokenizer:", {
+      logger4.error({
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
         model: modelConfig.name,
         tokenizer: modelConfig.tokenizer.name,
         modelsDir: this.modelsDir
-      });
+      }, "Failed to load tokenizer:");
       throw error;
     }
   }
   async encode(text, modelConfig) {
     try {
-      logger4.info("Encoding text with tokenizer:", {
+      logger4.info({
         length: text.length,
         tokenizer: modelConfig.tokenizer.name
-      });
+      }, "Encoding text with tokenizer:");
       const tokenizer = await this.loadTokenizer(modelConfig);
       logger4.info("Tokenizer loaded, encoding text...");
       const encoded = await tokenizer.encode(text, {
         add_special_tokens: true,
         return_token_type_ids: false
       });
-      logger4.info("Text encoded successfully:", {
+      logger4.info({
         tokenCount: encoded.length,
         tokenizer: modelConfig.tokenizer.name
-      });
+      }, "Text encoded successfully:");
       return encoded;
     } catch (error) {
-      logger4.error("Text encoding failed:", {
+      logger4.error({
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
         textLength: text.length,
         tokenizer: modelConfig.tokenizer.name,
         modelsDir: this.modelsDir
-      });
+      }, "Text encoding failed:");
       throw error;
     }
   }
   async decode(tokens, modelConfig) {
     try {
-      logger4.info("Decoding tokens with tokenizer:", {
+      logger4.info({
         count: tokens.length,
         tokenizer: modelConfig.tokenizer.name
-      });
+      }, "Decoding tokens with tokenizer:");
       const tokenizer = await this.loadTokenizer(modelConfig);
       logger4.info("Tokenizer loaded, decoding tokens...");
       const decoded = await tokenizer.decode(tokens, {
         skip_special_tokens: true,
         clean_up_tokenization_spaces: true
       });
-      logger4.info("Tokens decoded successfully:", {
+      logger4.info({
         textLength: decoded.length,
         tokenizer: modelConfig.tokenizer.name
-      });
+      }, "Tokens decoded successfully:");
       return decoded;
     } catch (error) {
-      logger4.error("Token decoding failed:", {
+      logger4.error({
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
         tokenCount: tokens.length,
         tokenizer: modelConfig.tokenizer.name,
         modelsDir: this.modelsDir
-      });
+      }, "Token decoding failed:");
       throw error;
     }
   }
@@ -862,10 +929,10 @@ class TranscribeManager {
   ffmpegInitialized = false;
   constructor(cacheDir) {
     this.cacheDir = path2.join(cacheDir, "whisper");
-    logger5.debug("Initializing TranscribeManager", {
+    logger5.debug({
       cacheDir: this.cacheDir,
       timestamp: new Date().toISOString()
-    });
+    }, "Initializing TranscribeManager");
     this.ensureCacheDirectory();
   }
   async ensureFFmpeg() {
@@ -874,11 +941,11 @@ class TranscribeManager {
         await this.initializeFFmpeg();
         this.ffmpegInitialized = true;
       } catch (error) {
-        logger5.error("FFmpeg initialization failed:", {
+        logger5.error({
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : undefined,
           timestamp: new Date().toISOString()
-        });
+        }, "FFmpeg initialization failed:");
         return false;
       }
     }
@@ -898,16 +965,16 @@ class TranscribeManager {
       const { stdout } = await execAsync2("ffmpeg -version");
       this.ffmpegVersion = stdout.split(`
 `)[0];
-      logger5.info("FFmpeg version:", {
+      logger5.info({
         version: this.ffmpegVersion,
         timestamp: new Date().toISOString()
-      });
+      }, "FFmpeg version:");
     } catch (error) {
       this.ffmpegVersion = null;
-      logger5.error("Failed to get FFmpeg version:", {
+      logger5.error({
         error: error instanceof Error ? error.message : String(error),
         timestamp: new Date().toISOString()
-      });
+      }, "Failed to get FFmpeg version:");
     }
   }
   async initializeFFmpeg() {
@@ -916,21 +983,21 @@ class TranscribeManager {
       if (this.ffmpegAvailable) {
         await this.fetchFFmpegVersion();
         await this.verifyFFmpegCapabilities();
-        logger5.success("FFmpeg initialized successfully", {
+        logger5.success({
           version: this.ffmpegVersion,
           path: this.ffmpegPath,
           timestamp: new Date().toISOString()
-        });
+        }, "FFmpeg initialized successfully");
       } else {
         this.logFFmpegInstallInstructions();
       }
     } catch (error) {
       this.ffmpegAvailable = false;
-      logger5.error("FFmpeg initialization failed:", {
+      logger5.error({
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
         timestamp: new Date().toISOString()
-      });
+      }, "FFmpeg initialization failed:");
       this.logFFmpegInstallInstructions();
     }
   }
@@ -939,19 +1006,19 @@ class TranscribeManager {
       const { stdout, stderr } = await execAsync2("which ffmpeg || where ffmpeg");
       this.ffmpegPath = stdout.trim();
       this.ffmpegAvailable = true;
-      logger5.info("FFmpeg found at:", {
+      logger5.info({
         path: this.ffmpegPath,
         stderr: stderr ? stderr.trim() : undefined,
         timestamp: new Date().toISOString()
-      });
+      }, "FFmpeg found at:");
     } catch (error) {
       this.ffmpegAvailable = false;
       this.ffmpegPath = null;
-      logger5.error("FFmpeg not found in PATH:", {
+      logger5.error({
         error: error instanceof Error ? error.message : String(error),
-        stderr: error instanceof Error && "stderr" in error ? error.stderr : undefined,
+        stderr: error instanceof Error && "stderr" in error ? String(error.code) : undefined,
         timestamp: new Date().toISOString()
-      });
+      }, "FFmpeg not found in PATH:");
     }
   }
   async verifyFFmpegCapabilities() {
@@ -962,15 +1029,15 @@ class TranscribeManager {
         throw new Error("FFmpeg installation missing required codecs (pcm_s16le, wav)");
       }
     } catch (error) {
-      logger5.error("FFmpeg capabilities verification failed:", {
+      logger5.error({
         error: error instanceof Error ? error.message : String(error),
         timestamp: new Date().toISOString()
-      });
+      }, "FFmpeg capabilities verification failed:");
       throw error;
     }
   }
   logFFmpegInstallInstructions() {
-    logger5.warn("FFmpeg is required but not properly installed. Please install FFmpeg:", {
+    logger5.warn({
       instructions: {
         mac: "brew install ffmpeg",
         ubuntu: "sudo apt-get install ffmpeg",
@@ -980,7 +1047,7 @@ class TranscribeManager {
       requiredVersion: "4.0 or later",
       requiredCodecs: ["pcm_s16le", "wav"],
       timestamp: new Date().toISOString()
-    });
+    }, "FFmpeg is required but not properly installed. Please install FFmpeg:");
   }
   static getInstance(cacheDir) {
     if (!TranscribeManager.instance) {
@@ -1000,18 +1067,18 @@ class TranscribeManager {
     try {
       const { stderr } = await execAsync2(`ffmpeg -y -loglevel error -i "${inputPath}" -acodec pcm_s16le -ar 16000 -ac 1 "${outputPath}"`);
       if (stderr) {
-        logger5.warn("FFmpeg conversion error:", {
+        logger5.warn({
           stderr,
           inputPath,
           outputPath,
           timestamp: new Date().toISOString()
-        });
+        }, "FFmpeg conversion error:");
       }
       if (!fs2.existsSync(outputPath)) {
         throw new Error("WAV file was not created successfully");
       }
     } catch (error) {
-      logger5.error("Audio conversion failed:", {
+      logger5.error({
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
         command: `ffmpeg -y -loglevel error -i "${inputPath}" -acodec pcm_s16le -ar 16000 -ac 1 "${outputPath}"`,
@@ -1019,7 +1086,7 @@ class TranscribeManager {
         ffmpegVersion: this.ffmpegVersion,
         ffmpegPath: this.ffmpegPath,
         timestamp: new Date().toISOString()
-      });
+      }, "Audio conversion failed:");
       throw new Error(`Failed to convert audio to WAV format: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
@@ -1043,7 +1110,7 @@ class TranscribeManager {
             return tempWavFile;
           }
         } catch (probeError) {
-          logger5.debug("FFprobe failed, continuing with conversion:", probeError);
+          logger5.debug({ error: probeError instanceof Error ? probeError.message : String(probeError) }, "FFprobe failed, continuing with conversion:");
         }
       }
       await this.convertToWav(tempInputFile, tempWavFile);
@@ -1052,12 +1119,12 @@ class TranscribeManager {
       }
       return tempWavFile;
     } catch (error) {
-      logger5.error("Audio preprocessing failed:", {
+      logger5.error({
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
         ffmpegAvailable: this.ffmpegAvailable,
         timestamp: new Date().toISOString()
-      });
+      }, "Audio preprocessing failed:");
       throw new Error(`Failed to preprocess audio: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
@@ -1086,7 +1153,7 @@ class TranscribeManager {
           logger5.error("Whisper model not found. Please run: npx whisper-node download");
           throw new Error("Whisper model not found. Please install it with: npx whisper-node download");
         }
-        logger5.error("Whisper transcription error:", whisperError);
+        logger5.error({ error: whisperError instanceof Error ? whisperError.message : String(whisperError) }, "Whisper transcription error:");
         throw whisperError;
       }
       if (fs2.existsSync(wavFile)) {
@@ -1102,18 +1169,18 @@ class TranscribeManager {
         return { text: "" };
       }
       const cleanText = segments.map((segment) => segment.speech?.trim() || "").filter((text) => text).join(" ");
-      logger5.success("Transcription complete:", {
+      logger5.success({
         textLength: cleanText.length,
         segmentCount: segments.length,
         timestamp: new Date().toISOString()
-      });
+      }, "Transcription complete:");
       return { text: cleanText };
     } catch (error) {
-      logger5.error("Transcription failed:", {
+      logger5.error({
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
         ffmpegAvailable: this.ffmpegAvailable
-      });
+      }, "Transcription failed:");
       throw error;
     }
   }
@@ -1125,7 +1192,6 @@ import path3 from "node:path";
 import { PassThrough, Readable } from "node:stream";
 import { logger as logger6 } from "@elizaos/core";
 import { pipeline } from "@huggingface/transformers";
-import { fetch as fetch2 } from "undici";
 function getWavHeader(audioLength, sampleRate, channelCount = 1, bitsPerSample = 16) {
   const wavHeader = Buffer.alloc(44);
   wavHeader.write("RIFF", 0);
@@ -1213,7 +1279,7 @@ class TTSManager {
             logger6.success("Default speaker embedding loaded from cache.");
           } else {
             logger6.info(`Downloading default speaker embedding from: ${speakerEmbeddingUrl}`);
-            const response = await fetch2(speakerEmbeddingUrl);
+            const response = await fetch(speakerEmbeddingUrl);
             if (!response.ok) {
               throw new Error(`Failed to download speaker embedding: ${response.statusText}`);
             }
@@ -1232,10 +1298,10 @@ class TTSManager {
         logger6.success("TTS initialization complete (Transformers.js)");
         this.initialized = true;
       } catch (error) {
-        logger6.error("TTS (Transformers.js) initialization failed:", {
+        logger6.error({
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : undefined
-        });
+        }, "TTS (Transformers.js) initialization failed:");
         this.initialized = false;
         this.synthesizer = null;
         this.defaultSpeakerEmbedding = null;
@@ -1252,9 +1318,7 @@ class TTSManager {
       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)}...`
-      });
+      logger6.info({ text: `${text.substring(0, 50)}...` }, "Starting speech generation with Transformers.js for text:");
       const output = await this.synthesizer(text, {
         ...this.defaultSpeakerEmbedding && {
           speaker_embeddings: this.defaultSpeakerEmbedding
@@ -1262,10 +1326,7 @@ class TTSManager {
       });
       const audioFloat32 = output.audio;
       const samplingRate = output.sampling_rate;
-      logger6.info("Raw audio data received from pipeline:", {
-        samplingRate,
-        length: audioFloat32.length
-      });
+      logger6.info({ samplingRate, length: audioFloat32.length }, "Raw audio data received from pipeline:");
       if (!audioFloat32 || audioFloat32.length === 0) {
         throw new Error("TTS pipeline generated empty audio output.");
       }
@@ -1275,18 +1336,16 @@ class TTSManager {
         pcmData[i] = s < 0 ? s * 32768 : s * 32767;
       }
       const audioBuffer = Buffer.from(pcmData.buffer);
-      logger6.info("Audio data converted to 16-bit PCM Buffer:", {
-        byteLength: audioBuffer.length
-      });
+      logger6.info({ byteLength: audioBuffer.length }, "Audio data converted to 16-bit PCM Buffer:");
       const audioStream = prependWavHeader(Readable.from(audioBuffer), audioBuffer.length, samplingRate, 1, 16);
       logger6.success("Speech generation complete (Transformers.js)");
       return audioStream;
     } catch (error) {
-      logger6.error("Transformers.js speech generation failed:", {
+      logger6.error({
         error: error instanceof Error ? error.message : String(error),
         text: `${text.substring(0, 50)}...`,
         stack: error instanceof Error ? error.stack : undefined
-      });
+      }, "Transformers.js speech generation failed:");
       throw error;
     }
   }
@@ -1333,7 +1392,7 @@ class VisionManager {
       dtype: "fp32",
       useOnnx: true
     };
-    if (platform === "darwin" && (arch === "arm64" || arch === "aarch64")) {
+    if (platform === "darwin" && arch === "arm64") {
       config = {
         device: "gpu",
         dtype: "fp16",
@@ -1414,11 +1473,11 @@ class VisionManager {
         this.model = model;
         logger7.success("Florence2 model loaded successfully");
       } catch (error) {
-        logger7.error("Failed to load Florence2 model:", {
+        logger7.error({
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : undefined,
           modelId: modelSpec.modelId
-        });
+        }, "Failed to load Florence2 model:");
         throw error;
       }
       logger7.info("Loading vision tokenizer...");
@@ -1446,11 +1505,11 @@ class VisionManager {
         });
         logger7.success("Vision tokenizer loaded successfully");
       } catch (error) {
-        logger7.error("Failed to load tokenizer:", {
+        logger7.error({
           error: error instanceof Error ? error.message : String(error),
           stack: error instanceof Error ? error.stack : undefined,
           modelId: modelSpec.modelId
-        });
+        }, "Failed to load tokenizer:");
         throw error;
       }
       logger7.info("Loading vision processor...");
@@ -1589,6 +1648,7 @@ class VisionManager {
 }
 
 // index.ts
+var DEFAULT_LOCAL_SYSTEM_PROMPT = "You are a helpful AI assistant. Respond to the current request only.";
 var wordsToPunish = [
   " please",
   " feel",
@@ -1639,6 +1699,84 @@ var wordsToPunish = [
   " Notably",
   " Therefore"
 ];
+function estimateTokenCount(text) {
+  return text.length === 0 ? 0 : Math.ceil(text.length / 4);
+}
+function estimateUsage(prompt, response) {
+  const responseText = typeof response === "string" ? response : (() => {
+    try {
+      return JSON.stringify(response);
+    } catch {
+      return String(response);
+    }
+  })();
+  const promptTokens = estimateTokenCount(prompt);
+  const completionTokens = estimateTokenCount(responseText);
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    estimated: true
+  };
+}
+function estimateEmbeddingUsage(text) {
+  const promptTokens = estimateTokenCount(text);
+  return {
+    promptTokens,
+    completionTokens: 0,
+    totalTokens: promptTokens,
+    estimated: true
+  };
+}
+function stripThinkTags(text) {
+  return text.includes("<think>") ? text.replace(/<think>[\s\S]*?<\/think>\n?/g, "") : text;
+}
+function wantsNativeShape(params) {
+  if (params.tools && params.tools.length > 0)
+    return true;
+  if (params.responseSchema)
+    return true;
+  if (params.toolChoice)
+    return true;
+  if (params.responseFormat && typeof params.responseFormat === "object" && params.responseFormat.type === "json_object") {
+    return true;
+  }
+  return false;
+}
+function buildNativeResult(result) {
+  return {
+    text: result.text,
+    toolCalls: result.toolCalls,
+    ...result.finishReason ? { finishReason: result.finishReason } : {}
+  };
+}
+function getLocalModelLabel(runtime, type) {
+  const config = validateConfig();
+  if (type === ModelType.TEXT_EMBEDDING) {
+    return String(runtime.getSetting("LOCAL_EMBEDDING_MODEL") || config.LOCAL_EMBEDDING_MODEL);
+  }
+  if (type === ModelType.TEXT_LARGE) {
+    return String(runtime.getSetting("LOCAL_LARGE_MODEL") || config.LOCAL_LARGE_MODEL);
+  }
+  return String(runtime.getSetting("LOCAL_SMALL_MODEL") || config.LOCAL_SMALL_MODEL);
+}
+function emitModelUsed(runtime, type, model, usage) {
+  runtime.emitEvent(EventType.MODEL_USED, {
+    runtime,
+    source: "local-ai",
+    provider: "local-ai",
+    type,
+    model,
+    modelName: model,
+    tokens: {
+      prompt: usage.promptTokens,
+      completion: usage.completionTokens,
+      total: usage.totalTokens,
+      ...usage.estimated ? { estimated: true } : {}
+    },
+    ...usage.estimated ? { usageEstimated: true } : {}
+  });
+}
 
 class LocalAIManager {
   static instance = null;
@@ -1647,9 +1785,7 @@ class LocalAIManager {
   mediumModel;
   embeddingModel;
   embeddingContext;
-  ctx;
-  sequence;
-  chatSession;
+  chatSessions = new Map;
   modelPath;
   mediumModelPath;
   embeddingModelPath;
@@ -1876,80 +2012,120 @@ class LocalAIManager {
     }
     await this.embeddingInitializingPromise;
   }
-  async generateText(params) {
-    if (this.ctx) {
-      this.ctx.dispose();
-      this.ctx = undefined;
+  async getOrCreateChatSession(modelType, systemPrompt) {
+    const existing = this.chatSessions.get(modelType);
+    if (existing && existing.systemPrompt === systemPrompt) {
+      return existing;
     }
-    await this.initializeEnvironment();
-    logger8.info("Generating text with model:", params.modelType);
-    if (params.modelType === ModelType.TEXT_LARGE) {
+    if (existing) {
+      try {
+        existing.context.dispose();
+      } catch (err) {
+        logger8.warn("[plugin-local-ai] Failed disposing stale context:", err);
+      }
+      this.chatSessions.delete(modelType);
+    }
+    let model;
+    let contextSize;
+    if (modelType === ModelType.TEXT_LARGE) {
       await this.lazyInitMediumModel();
-      if (!this.mediumModel) {
+      if (!this.mediumModel)
         throw new Error("Medium model initialization failed");
-      }
+      model = this.mediumModel;
+      contextSize = MODEL_SPECS.medium.contextSize;
       this.activeModelConfig = MODEL_SPECS.medium;
-      const mediumModel = this.mediumModel;
-      this.ctx = await mediumModel.createContext({
-        contextSize: MODEL_SPECS.medium.contextSize
-      });
     } else {
       await this.lazyInitSmallModel();
-      if (!this.smallModel) {
+      if (!this.smallModel)
         throw new Error("Small model initialization failed");
-      }
+      model = this.smallModel;
+      contextSize = MODEL_SPECS.small.contextSize;
       this.activeModelConfig = MODEL_SPECS.small;
-      const smallModel = this.smallModel;
-      this.ctx = await smallModel.createContext({
-        contextSize: MODEL_SPECS.small.contextSize
-      });
     }
-    if (!this.ctx) {
-      throw new Error("Failed to create prompt");
-    }
-    this.sequence = this.ctx.getSequence();
-    this.chatSession = new LlamaChatSession({
-      contextSequence: this.sequence
+    const context = await model.createContext({ contextSize });
+    const sequence = context.getSequence();
+    const session = new LlamaChatSession({
+      contextSequence: sequence,
+      systemPrompt
+    });
+    const entry = { context, session, systemPrompt };
+    this.chatSessions.set(modelType, entry);
+    logger8.info("[plugin-local-ai] Created new chat session", {
+      modelType,
+      contextSize,
+      systemPromptLength: systemPrompt.length
     });
-    if (!this.chatSession) {
-      throw new Error("Failed to create chat session");
-    }
-    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
+    return entry;
+  }
+  async generateText(params) {
+    await this.initializeEnvironment();
+    const modelType = params.modelType ?? ModelType.TEXT_SMALL;
+    const systemPrompt = params.system?.trim() || DEFAULT_LOCAL_SYSTEM_PROMPT;
+    const entry = await this.getOrCreateChatSession(modelType, systemPrompt);
+    const prompt = params.prompt ?? "";
+    if (!this.llama)
+      throw new Error("[plugin-local-ai] Llama runtime not initialized");
+    const plan = await planStructuredRequest({ llama: this.llama }, {
+      tools: params.tools,
+      responseSchema: params.responseSchema,
+      responseFormat: params.responseFormat
     });
-    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,
-      temperature: 0
+    const usedTokensBefore = entry.session.sequence?.contextTokens?.length ?? 0;
+    logger8.info("[plugin-local-ai] generateText", {
+      modelType,
+      kind: plan.kind,
+      promptLength: prompt.length,
+      cachedPrefixTokens: usedTokensBefore
     });
-    let response = await this.chatSession.prompt(params.prompt, {
-      maxTokens: 8192,
-      temperature: 0.7,
-      topP: 0.9,
+    const punishModel = modelType === ModelType.TEXT_LARGE ? this.mediumModel : this.smallModel;
+    const baseOptions = {
+      maxTokens: params.maxTokens ?? 8192,
+      temperature: params.temperature ?? 0.7,
+      topP: params.topP ?? 0.9,
       repeatPenalty: {
-        punishTokensFilter: () => this.smallModel ? this.smallModel.tokenize(wordsToPunish.join(" ")) : [],
+        punishTokensFilter: () => punishModel ? punishModel.tokenize(wordsToPunish.join(" ")) : [],
         penalty: 1.2,
         frequencyPenalty: 0.7,
         presencePenalty: 0.7
       }
-    });
-    logger8.info("Raw response structure:", {
-      responseLength: response.length,
-      hasAction: response.includes("action"),
-      hasThinkTag: response.includes("<think>")
-    });
-    if (response.includes("<think>")) {
-      logger8.info("Cleaning think tags from response");
-      response = response.replace(/<think>[\s\S]*?<\/think>\n?/g, "");
-      logger8.info("Think tags removed from response");
+    };
+    if (plan.kind === "tools") {
+      const meta = await entry.session.promptWithMeta(prompt, {
+        ...baseOptions,
+        functions: plan.functions
+      });
+      const toolCalls = extractToolCalls(meta.response);
+      const text2 = stripThinkTags(meta.responseText);
+      const usedTokensAfter2 = entry.session.sequence?.contextTokens?.length ?? 0;
+      logger8.info("[plugin-local-ai] tool-call response", {
+        toolCallCount: toolCalls.length,
+        textLength: text2.length,
+        cacheGrewBy: usedTokensAfter2 - usedTokensBefore
+      });
+      return { text: text2, toolCalls, finishReason: meta.stopReason };
     }
-    return response;
+    if (plan.kind === "schema" || plan.kind === "json_object") {
+      const meta = await entry.session.promptWithMeta(prompt, {
+        ...baseOptions,
+        grammar: plan.grammar
+      });
+      const text2 = stripThinkTags(meta.responseText);
+      const usedTokensAfter2 = entry.session.sequence?.contextTokens?.length ?? 0;
+      logger8.info("[plugin-local-ai] structured response", {
+        kind: plan.kind,
+        textLength: text2.length,
+        cacheGrewBy: usedTokensAfter2 - usedTokensBefore
+      });
+      return { text: text2, toolCalls: [], finishReason: meta.stopReason };
+    }
+    const responseText = await entry.session.prompt(prompt, baseOptions);
+    const text = stripThinkTags(responseText);
+    const usedTokensAfter = entry.session.sequence?.contextTokens?.length ?? 0;
+    logger8.info("[plugin-local-ai] text response", {
+      textLength: text.length,
+      cacheGrewBy: usedTokensAfter - usedTokensBefore
+    });
+    return { text, toolCalls: [], finishReason: undefined };
   }
   async describeImage(imageData, mimeType) {
     await this.lazyInitVision();
@@ -1995,11 +2171,6 @@ class LocalAIManager {
           vocabOnly: false
         });
         this.smallModel = smallModel;
-        const ctx = await smallModel.createContext({
-          contextSize: MODEL_SPECS.small.contextSize
-        });
-        this.ctx = ctx;
-        this.sequence = undefined;
         this.smallModelInitialized = true;
         logger8.info("Small model initialized successfully");
       })();
@@ -2089,7 +2260,7 @@ class LocalAIManager {
 var localAIManager = LocalAIManager.getInstance();
 var localAiPlugin = {
   name: "local-ai",
-  description: "Local AI plugin using LLaMA models",
+  description: "Local AI plugin using Eliza-1 GGUF models",
   async init(_config, _runtime) {
     logger8.info("\uD83D\uDE80 Initializing Local AI plugin...");
     await localAIManager.initializeEnvironment();
@@ -2100,7 +2271,7 @@ var localAiPlugin = {
       logger8.warn("- LOCAL_SMALL_MODEL: Path to small language model file");
       logger8.warn("- LOCAL_LARGE_MODEL: Path to large language model file");
       logger8.warn("- LOCAL_EMBEDDING_MODEL: Path to embedding model file");
-      logger8.warn("Example: LOCAL_SMALL_MODEL=llama-3.2-1b-instruct-q8_0.gguf");
+      logger8.warn("Example: LOCAL_SMALL_MODEL=text/eliza-1-mobile-1_7b-32k.gguf");
     }
     const modelsDir = config.MODELS_DIR || path5.join(os3.homedir(), ".eliza", "models");
     if (!fs5.existsSync(modelsDir)) {
@@ -2139,247 +2310,33 @@ var localAiPlugin = {
     logger8.info("\uD83D\uDCA1 Models will be loaded on-demand when first used");
   },
   models: {
-    [ModelType.TEXT_SMALL]: async (runtime, { prompt, stopSequences = [] }) => {
+    [ModelType.TEXT_SMALL]: async (runtime, params) => {
       await localAIManager.initializeEnvironment();
-      return await localAIManager.generateText({
-        prompt,
-        stopSequences,
-        runtime,
+      const result = await localAIManager.generateText({
+        ...params,
         modelType: ModelType.TEXT_SMALL
       });
+      emitModelUsed(runtime, ModelType.TEXT_SMALL, getLocalModelLabel(runtime, ModelType.TEXT_SMALL), estimateUsage(params.prompt ?? "", result.text));
+      return wantsNativeShape(params) ? buildNativeResult(result) : result.text;
     },
-    [ModelType.TEXT_LARGE]: async (runtime, { prompt, stopSequences = [] }) => {
+    [ModelType.TEXT_LARGE]: async (runtime, params) => {
       await localAIManager.initializeEnvironment();
-      return await localAIManager.generateText({
-        prompt,
-        stopSequences,
-        runtime,
+      const result = await localAIManager.generateText({
+        ...params,
         modelType: ModelType.TEXT_LARGE
       });
+      emitModelUsed(runtime, ModelType.TEXT_LARGE, getLocalModelLabel(runtime, ModelType.TEXT_LARGE), estimateUsage(params.prompt ?? "", result.text));
+      return wantsNativeShape(params) ? buildNativeResult(result) : result.text;
     },
-    [ModelType.TEXT_EMBEDDING]: async (_runtime, params) => {
+    [ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
       const text = params?.text;
       if (!text) {
         logger8.debug("Null or empty text input for embedding, returning zero vector");
-        return new Array(384).fill(0);
-      }
-      return await localAIManager.generateEmbedding(text);
-    },
-    [ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      await localAIManager.initializeEnvironment();
-      logger8.info("OBJECT_SMALL handler - Processing request:", {
-        prompt: params.prompt,
-        hasSchema: !!params.schema,
-        temperature: params.temperature
-      });
-      let schemaHint = "";
-      if (params.schema) {
-        const schemaKeys = Object.keys(params.schema);
-        schemaHint = schemaKeys.map((key) => `<${key}>value</${key}>`).join(`
-`);
-      }
-      const xmlPrompt = `${params.prompt}
-
-Respond using XML format wrapped in <response> tags. ${schemaHint ? `Include these fields:
-${schemaHint}` : ""}
-
-IMPORTANT: If your response contains code, wrap code blocks in CDATA sections like this:
-<code><![CDATA[
-your code here
-]]></code>
-
-Example response format:
-<response>
-<thought>Your reasoning here</thought>
-<text>Your response text here</text>
-</response>`;
-      const textResponse = await localAIManager.generateText({
-        prompt: xmlPrompt,
-        stopSequences: params.stopSequences,
-        runtime,
-        modelType: ModelType.TEXT_SMALL
-      });
-      try {
-        logger8.debug("Raw model response:", textResponse.substring(0, 500));
-        const parsedXml = parseKeyValueXml(textResponse);
-        if (parsedXml) {
-          logger8.debug("Parsed XML result:", parsedXml);
-          if (params.schema) {
-            for (const key of Object.keys(params.schema)) {
-              if (!(key in parsedXml)) {
-                parsedXml[key] = null;
-              }
-            }
-          }
-          return parsedXml;
-        }
-        logger8.warn("parseKeyValueXml returned null, attempting manual extraction");
-        const result = {};
-        const extractTag = (text2, tagName) => {
-          const cdataPattern = new RegExp(`<${tagName}>\\s*<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>\\s*</${tagName}>`, "i");
-          const cdataMatch = text2.match(cdataPattern);
-          if (cdataMatch) {
-            return cdataMatch[1];
-          }
-          const startTag = `<${tagName}>`;
-          const endTag = `</${tagName}>`;
-          const startIdx = text2.indexOf(startTag);
-          if (startIdx === -1)
-            return null;
-          let depth = 1;
-          let searchStart = startIdx + startTag.length;
-          while (depth > 0 && searchStart < text2.length) {
-            const nextOpen = text2.indexOf(startTag, searchStart);
-            const nextClose = text2.indexOf(endTag, searchStart);
-            if (nextClose === -1)
-              break;
-            if (nextOpen !== -1 && nextOpen < nextClose) {
-              depth++;
-              searchStart = nextOpen + startTag.length;
-            } else {
-              depth--;
-              if (depth === 0) {
-                return text2.slice(startIdx + startTag.length, nextClose).trim();
-              }
-              searchStart = nextClose + endTag.length;
-            }
-          }
-          return null;
-        };
-        const thought = extractTag(textResponse, "thought");
-        const text = extractTag(textResponse, "text");
-        const code = extractTag(textResponse, "code");
-        if (thought)
-          result.thought = thought;
-        if (text)
-          result.text = text;
-        if (code)
-          result.code = code;
-        if (params.schema) {
-          for (const key of Object.keys(params.schema)) {
-            if (!(key in result)) {
-              const value = extractTag(textResponse, key);
-              result[key] = value;
-            }
-          }
-        }
-        if (Object.keys(result).length > 0) {
-          return result;
-        }
-        throw new Error("Could not parse XML response");
-      } catch (parseError) {
-        logger8.error("Failed to parse XML:", parseError);
-        logger8.error("Raw response:", textResponse);
-        throw new Error("Invalid XML returned from model");
-      }
-    },
-    [ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      await localAIManager.initializeEnvironment();
-      logger8.info("OBJECT_LARGE handler - Processing request:", {
-        prompt: params.prompt,
-        hasSchema: !!params.schema,
-        temperature: params.temperature
-      });
-      let schemaHint = "";
-      if (params.schema) {
-        const schemaKeys = Object.keys(params.schema);
-        schemaHint = schemaKeys.map((key) => `<${key}>value</${key}>`).join(`
-`);
-      }
-      const xmlPrompt = `${params.prompt}
-
-Respond using XML format wrapped in <response> tags. ${schemaHint ? `Include these fields:
-${schemaHint}` : ""}
-
-IMPORTANT: If your response contains code, wrap code blocks in CDATA sections like this:
-<code><![CDATA[
-your code here
-]]></code>
-
-Example response format:
-<response>
-<thought>Your reasoning here</thought>
-<text>Your response text here</text>
-</response>`;
-      const textResponse = await localAIManager.generateText({
-        prompt: xmlPrompt,
-        stopSequences: params.stopSequences,
-        runtime,
-        modelType: ModelType.TEXT_LARGE
-      });
-      try {
-        logger8.debug("Raw model response:", textResponse.substring(0, 500));
-        const parsedXml = parseKeyValueXml(textResponse);
-        if (parsedXml) {
-          logger8.debug("Parsed XML result:", parsedXml);
-          if (params.schema) {
-            for (const key of Object.keys(params.schema)) {
-              if (!(key in parsedXml)) {
-                parsedXml[key] = null;
-              }
-            }
-          }
-          return parsedXml;
-        }
-        logger8.warn("parseKeyValueXml returned null, attempting manual extraction");
-        const result = {};
-        const extractTag = (text2, tagName) => {
-          const cdataPattern = new RegExp(`<${tagName}>\\s*<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>\\s*</${tagName}>`, "i");
-          const cdataMatch = text2.match(cdataPattern);
-          if (cdataMatch) {
-            return cdataMatch[1];
-          }
-          const startTag = `<${tagName}>`;
-          const endTag = `</${tagName}>`;
-          const startIdx = text2.indexOf(startTag);
-          if (startIdx === -1)
-            return null;
-          let depth = 1;
-          let searchStart = startIdx + startTag.length;
-          while (depth > 0 && searchStart < text2.length) {
-            const nextOpen = text2.indexOf(startTag, searchStart);
-            const nextClose = text2.indexOf(endTag, searchStart);
-            if (nextClose === -1)
-              break;
-            if (nextOpen !== -1 && nextOpen < nextClose) {
-              depth++;
-              searchStart = nextOpen + startTag.length;
-            } else {
-              depth--;
-              if (depth === 0) {
-                return text2.slice(startIdx + startTag.length, nextClose).trim();
-              }
-              searchStart = nextClose + endTag.length;
-            }
-          }
-          return null;
-        };
-        const thought = extractTag(textResponse, "thought");
-        const text = extractTag(textResponse, "text");
-        const code = extractTag(textResponse, "code");
-        if (thought)
-          result.thought = thought;
-        if (text)
-          result.text = text;
-        if (code)
-          result.code = code;
-        if (params.schema) {
-          for (const key of Object.keys(params.schema)) {
-            if (!(key in result)) {
-              const value = extractTag(textResponse, key);
-              result[key] = value;
-            }
-          }
-        }
-        if (Object.keys(result).length > 0) {
-          return result;
-        }
-        throw new Error("Could not parse XML response");
-      } catch (parseError) {
-        logger8.error("Failed to parse XML:", parseError);
-        logger8.error("Raw response:", textResponse);
-        throw new Error("Invalid XML returned from model");
+        return new Array(1024).fill(0);
       }
+      const embedding = await localAIManager.generateEmbedding(text);
+      emitModelUsed(runtime, ModelType.TEXT_EMBEDDING, getLocalModelLabel(runtime, ModelType.TEXT_EMBEDDING), estimateEmbeddingUsage(text));
+      return embedding;
     },
     [ModelType.TEXT_TOKENIZER_ENCODE]: async (_runtime, { text }) => {
       const manager = localAIManager.getTokenizerManager();
@@ -2666,10 +2623,9 @@ Example response format:
     }
   ]
 };
-var typescript_default = localAiPlugin;
 export {
   localAiPlugin,
-  typescript_default as default
+  default2 as default
 };
 
-//# debugId=47689E660851F59964756E2164756E21
+//# debugId=B1A63AD720108B0264756E2164756E21