@elizaos/plugin-vision 2.0.0-alpha.8 → 2.0.0-beta.1

package/dist/index.js

@@ -1,22 +1,9 @@
 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);
 
+// src/index.ts
+import { promoteSubactionsToActions } from "@elizaos/core";
+
 // src/action.ts
 import {
   ContentType,
@@ -30,6 +17,200 @@ var VisionServiceType = {
 };
 
 // src/action.ts
+var VISION_ACTION_TIMEOUT_MS = 1e4;
+var MAX_VISION_TEXT_LENGTH = 4000;
+var MAX_VISION_ENTITIES = 25;
+var VISION_OPS = [
+  "describe",
+  "capture",
+  "set_mode",
+  "name_entity",
+  "identify_person",
+  "track_entity"
+];
+var ALL_VISION_CONTEXTS = [
+  "media",
+  "screen_time",
+  "automation",
+  "memory",
+  "settings"
+];
+var DESCRIBE_KEYWORDS = [
+  "describe",
+  "scene",
+  "see",
+  "look",
+  "camera",
+  "screen",
+  "object",
+  "person",
+  "escena",
+  "ver",
+  "camara",
+  "décrire",
+  "scène",
+  "voir",
+  "beschreiben",
+  "szene",
+  "sehen",
+  "descrivi",
+  "scena",
+  "vedi",
+  "説明",
+  "見える",
+  "场景",
+  "描述",
+  "看见",
+  "장면",
+  "설명",
+  "보여"
+];
+var CAPTURE_KEYWORDS = [
+  "capture",
+  "image",
+  "photo",
+  "picture",
+  "snapshot",
+  "screenshot",
+  "camera",
+  "captura",
+  "foto",
+  "imagen",
+  "capturer",
+  "photo",
+  "bild",
+  "foto",
+  "capturare",
+  "写真",
+  "画像",
+  "スクリーンショット",
+  "拍照",
+  "截图",
+  "이미지",
+  "사진",
+  "스크린샷"
+];
+var SET_MODE_KEYWORDS = [
+  "vision",
+  "mode",
+  "camera",
+  "screen",
+  "both",
+  "disable",
+  "enable",
+  "off",
+  "visión",
+  "camara",
+  "pantalla",
+  "écran",
+  "kamera",
+  "bildschirm",
+  "schermo",
+  "ビジョン",
+  "カメラ",
+  "画面",
+  "视觉",
+  "相机",
+  "屏幕",
+  "비전",
+  "카메라",
+  "화면"
+];
+var NAME_ENTITY_KEYWORDS = [
+  "name",
+  "named",
+  "call",
+  "person",
+  "entity",
+  "remember",
+  "object",
+  "nombre",
+  "llama",
+  "persona",
+  "nom",
+  "appelle",
+  "personne",
+  "name",
+  "nenne",
+  "person",
+  "nome",
+  "chiama",
+  "persona",
+  "名前",
+  "呼ぶ",
+  "人",
+  "命名",
+  "叫",
+  "人",
+  "이름",
+  "불러",
+  "사람"
+];
+var IDENTIFY_PERSON_KEYWORDS = [
+  "identify",
+  "recognize",
+  "who is",
+  "person",
+  "face",
+  "seen before",
+  "identificar",
+  "reconoces",
+  "persona",
+  "visage",
+  "reconnais",
+  "personne",
+  "erkennen",
+  "gesicht",
+  "person",
+  "riconosci",
+  "persona",
+  "識別",
+  "誰",
+  "顔",
+  "识别",
+  "是谁",
+  "人",
+  "식별",
+  "누구",
+  "얼굴"
+];
+var TRACK_ENTITY_KEYWORDS = [
+  "track",
+  "follow",
+  "watch",
+  "keep an eye",
+  "entity",
+  "person",
+  "object",
+  "rastrear",
+  "seguir",
+  "vigilar",
+  "persona",
+  "suivre",
+  "surveiller",
+  "personne",
+  "verfolgen",
+  "beobachten",
+  "person",
+  "traccia",
+  "segui",
+  "persona",
+  "追跡",
+  "見張",
+  "人",
+  "跟踪",
+  "关注",
+  "人",
+  "추적",
+  "지켜봐",
+  "사람"
+];
+function withVisionTimeout(promise, label) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out`)), VISION_ACTION_TIMEOUT_MS))
+  ]);
+}
 async function saveExecutionRecord(runtime, messageContext, thought, text, actions, attachments) {
   const memory = {
     id: createUniqueUuid(runtime, `vision-record-${Date.now()}`),
@@ -47,1108 +228,1004 @@ async function saveExecutionRecord(runtime, messageContext, thought, text, actio
   };
   await runtime.createMemory(memory, "messages");
 }
-var describeSceneAction = {
-  name: "DESCRIBE_SCENE",
-  similes: ["ANALYZE_SCENE", "WHAT_DO_YOU_SEE", "VISION_CHECK", "LOOK_AROUND"],
-  description: "Analyzes the current visual scene and provides a detailed description of what the agent sees through the camera. Returns scene analysis data including people count, objects, and camera info for action chaining.",
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avVisionService = runtime?.getService?.("VISION");
-    const __avLegacyContextOk = Boolean(__avVisionService && typeof __avVisionService.isActive === "function" && __avVisionService.isActive());
-    const __avKeywords = ["describe", "scene"];
-    const __avKeywordOk = __avKeywords.length > 0 && (__avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || __avLegacyContextOk);
-    const __avRegex = new RegExp("\\b(?:describe|scene)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const visionService = runtime2.getService("VISION");
-      return !!visionService && visionService.isActive();
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
+function readActionParams(options) {
+  const direct = options && typeof options === "object" ? options : {};
+  const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
+  return { ...direct, ...parameters };
+}
+function selectedContextMatches(state, contexts) {
+  const selected = new Set;
+  const collect = (value) => {
+    if (!Array.isArray(value))
+      return;
+    for (const item of value) {
+      if (typeof item === "string")
+        selected.add(item);
     }
-  },
-  handler: async (runtime, message, _state, _options, callback, _responses) => {
-    const visionService = runtime.getService("VISION");
-    if (!visionService || !visionService.isActive()) {
-      const thought = "Vision service is not available or no camera is connected.";
-      const text = "I cannot see anything right now. No camera is available.";
-      await saveExecutionRecord(runtime, message, thought, text, ["DESCRIBE_SCENE"]);
+  };
+  collect(state?.values?.selectedContexts);
+  collect(state?.data?.selectedContexts);
+  const contextObject = state?.data?.contextObject;
+  collect(contextObject?.trajectoryPrefix?.selectedContexts);
+  collect(contextObject?.metadata?.selectedContexts);
+  return contexts.some((context) => selected.has(context));
+}
+function visionServiceIsActive(runtime) {
+  const visionService = runtime.getService("VISION");
+  return Boolean(visionService?.isActive());
+}
+function normalizeOp(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (!normalized)
+    return null;
+  const aliases = {
+    describe_scene: "describe",
+    scene: "describe",
+    capture_image: "capture",
+    image: "capture",
+    photo: "capture",
+    snapshot: "capture",
+    screenshot: "capture",
+    set_vision_mode: "set_mode",
+    mode: "set_mode",
+    vision_mode: "set_mode",
+    name: "name_entity",
+    identify: "identify_person",
+    recognize: "identify_person",
+    track: "track_entity",
+    follow: "track_entity"
+  };
+  if (aliases[normalized])
+    return aliases[normalized];
+  return VISION_OPS.includes(normalized) ? normalized : null;
+}
+function inferOpFromMessage(text) {
+  const lower = text.toLowerCase();
+  if (NAME_ENTITY_KEYWORDS.some((k) => lower.includes(k.toLowerCase())) && /\b(call|name|named)\b/.test(lower)) {
+    return "name_entity";
+  }
+  if (IDENTIFY_PERSON_KEYWORDS.some((k) => lower.includes(k.toLowerCase())) && /\b(who|identify|recognize)\b/.test(lower)) {
+    return "identify_person";
+  }
+  if (TRACK_ENTITY_KEYWORDS.some((k) => lower.includes(k.toLowerCase())) && /\b(track|follow|watch|keep an eye)\b/.test(lower)) {
+    return "track_entity";
+  }
+  if (SET_MODE_KEYWORDS.some((k) => lower.includes(k.toLowerCase())) && /\b(mode|enable|disable|turn off|turn on)\b/.test(lower)) {
+    return "set_mode";
+  }
+  if (CAPTURE_KEYWORDS.some((k) => lower.includes(k.toLowerCase()))) {
+    return "capture";
+  }
+  if (DESCRIBE_KEYWORDS.some((k) => lower.includes(k.toLowerCase()))) {
+    return "describe";
+  }
+  return null;
+}
+async function runDescribe(runtime, message, options, callback) {
+  const visionService = runtime.getService("VISION");
+  if (!visionService || !visionService.isActive()) {
+    const thought = "Vision service is not available or no camera is connected.";
+    const text = "I cannot see anything right now. No camera is available.";
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: false,
+      text: "Vision service unavailable - cannot analyze scene",
+      values: {
+        success: false,
+        visionAvailable: false,
+        error: "Vision service not available"
+      },
+      data: {
+        actionName: "VISION",
+        op: "describe",
+        error: "Vision service not available or no camera connected"
+      }
+    };
+  }
+  try {
+    const scene = await withVisionTimeout(visionService.getSceneDescription(), "vision scene description");
+    const cameraInfo = visionService.getCameraInfo();
+    if (!scene) {
+      const thought2 = "Camera is connected but no scene has been analyzed yet.";
+      const text2 = `Camera "${cameraInfo?.name}" is connected, but I haven't analyzed any scenes yet. Please wait a moment.`;
+      await saveExecutionRecord(runtime, message, thought2, text2, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["DESCRIBE_SCENE"]
-        });
+        await callback({ thought: thought2, text: text2, actions: ["VISION"] });
       }
       return {
         success: false,
-        text: "Vision service unavailable - cannot analyze scene",
+        text: "Camera connected but no scene analyzed yet",
         values: {
           success: false,
-          visionAvailable: false,
-          error: "Vision service not available"
+          visionAvailable: true,
+          sceneAnalyzed: false,
+          cameraName: cameraInfo?.name || undefined
         },
         data: {
-          actionName: "DESCRIBE_SCENE",
-          error: "Vision service not available or no camera connected"
+          actionName: "VISION",
+          op: "describe",
+          cameraInfo: cameraInfo ? {
+            id: cameraInfo.id,
+            name: cameraInfo.name,
+            connected: cameraInfo.connected
+          } : undefined,
+          sceneStatus: "not_analyzed"
         }
       };
     }
-    try {
-      const scene = await visionService.getSceneDescription();
-      const cameraInfo = visionService.getCameraInfo();
-      if (!scene) {
-        const thought2 = "Camera is connected but no scene has been analyzed yet.";
-        const text2 = `Camera "${cameraInfo?.name}" is connected, but I haven't analyzed any scenes yet. Please wait a moment.`;
-        await saveExecutionRecord(runtime, message, thought2, text2, ["DESCRIBE_SCENE"]);
-        if (callback) {
-          await callback({
-            thought: thought2,
-            text: text2,
-            actions: ["DESCRIBE_SCENE"]
-          });
-        }
-        return {
-          success: false,
-          text: "Camera connected but no scene analyzed yet",
-          values: {
-            success: false,
-            visionAvailable: true,
-            sceneAnalyzed: false,
-            cameraName: cameraInfo?.name || undefined
-          },
-          data: {
-            actionName: "DESCRIBE_SCENE",
-            cameraInfo: cameraInfo ? {
-              id: cameraInfo.id,
-              name: cameraInfo.name,
-              connected: cameraInfo.connected
-            } : undefined,
-            sceneStatus: "not_analyzed"
-          }
-        };
-      }
-      const peopleCount = scene.people.length;
-      const objectCount = scene.objects.length;
-      const timestamp = new Date(scene.timestamp).toLocaleString();
-      let description = `Looking through ${cameraInfo?.name || "the camera"}, `;
-      description += scene.description;
-      if (peopleCount > 0) {
-        description += `
+    const peopleCount = scene.people.length;
+    const objectCount = scene.objects.length;
+    const people = scene.people.slice(0, MAX_VISION_ENTITIES);
+    const objects = scene.objects.slice(0, MAX_VISION_ENTITIES);
+    const timestamp = new Date(scene.timestamp).toLocaleString();
+    const detailLevel = options.detailLevel === "summary" ? "summary" : "detailed";
+    let description = `Looking through ${cameraInfo?.name || "the camera"}, `;
+    description += scene.description;
+    if (detailLevel === "detailed" && peopleCount > 0) {
+      description += `
 
 I can see ${peopleCount} ${peopleCount === 1 ? "person" : "people"}`;
-        const facingData = scene.people.reduce((acc, person) => {
-          if (person.facing && person.facing !== "unknown") {
-            acc[person.facing] = (acc[person.facing] || 0) + 1;
-          }
-          return acc;
-        }, {});
-        if (Object.keys(facingData).length > 0) {
-          const facingDescriptions = Object.entries(facingData).map(([direction, count]) => `${count} facing ${direction}`);
-          description += ` (${facingDescriptions.join(", ")})`;
-        }
-        description += ".";
-      }
-      if (objectCount > 0) {
-        const objectTypes = scene.objects.reduce((acc, obj) => {
-          acc[obj.type] = (acc[obj.type] || 0) + 1;
-          return acc;
-        }, {});
-        const objectDescriptions = Object.entries(objectTypes).map(([type, count]) => `${count} ${type}${count > 1 ? "s" : ""}`);
-        description += `
+      const facingData = people.reduce((acc, person) => {
+        if (person.facing && person.facing !== "unknown") {
+          acc[person.facing] = (acc[person.facing] || 0) + 1;
+        }
+        return acc;
+      }, {});
+      if (Object.keys(facingData).length > 0) {
+        const facingDescriptions = Object.entries(facingData).map(([direction, count]) => `${count} facing ${direction}`);
+        description += ` (${facingDescriptions.join(", ")})`;
+      }
+      description += ".";
+    }
+    if (detailLevel === "detailed" && objectCount > 0) {
+      const objectTypes = objects.reduce((acc, obj) => {
+        acc[obj.type] = (acc[obj.type] || 0) + 1;
+        return acc;
+      }, {});
+      const objectDescriptions = Object.entries(objectTypes).map(([type, count]) => `${count} ${type}${count > 1 ? "s" : ""}`);
+      description += `
 
 Objects detected: ${objectDescriptions.join(", ")}.`;
-      }
-      if (scene.sceneChanged && scene.changePercentage) {
-        description += `
+    }
+    if (detailLevel === "detailed" && scene.sceneChanged && scene.changePercentage) {
+      description += `
 
 (Scene changed by ${scene.changePercentage.toFixed(1)}% since last analysis)`;
+    }
+    const thought = `Analyzed the visual scene at ${timestamp}.`;
+    const text = description.slice(0, MAX_VISION_TEXT_LENGTH);
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        success: true,
+        visionAvailable: true,
+        sceneAnalyzed: true,
+        peopleCount,
+        objectCount,
+        cameraName: cameraInfo?.name || undefined,
+        sceneChanged: scene.sceneChanged,
+        changePercentage: scene.changePercentage,
+        detailLevel
+      },
+      data: {
+        actionName: "VISION",
+        op: "describe",
+        sceneTimestamp: scene.timestamp,
+        sceneDescription: scene.description.slice(0, MAX_VISION_TEXT_LENGTH),
+        sceneChanged: scene.sceneChanged,
+        changePercentage: scene.changePercentage,
+        audioTranscription: scene.audioTranscription || undefined,
+        objectCount: objects.length,
+        peopleCount: people.length,
+        cameraInfo: cameraInfo ? {
+          id: cameraInfo.id,
+          name: cameraInfo.name,
+          connected: cameraInfo.connected
+        } : undefined,
+        timestamp,
+        description: text
+      }
+    };
+  } catch (error) {
+    logger.error("[VISION/describe] Error analyzing scene:", error instanceof Error ? error.message : String(error));
+    const thought = "An error occurred while trying to analyze the visual scene.";
+    const text = `Error analyzing scene: ${error instanceof Error ? error.message : String(error)}`;
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      text: "Error analyzing scene",
+      values: {
+        success: false,
+        visionAvailable: true,
+        error: true,
+        errorMessage
+      },
+      data: {
+        actionName: "VISION",
+        op: "describe",
+        error: errorMessage,
+        errorType: "analysis_error"
+      }
+    };
+  }
+}
+async function runCapture(runtime, message, callback) {
+  const visionService = runtime.getService("VISION");
+  if (!visionService || !visionService.isActive()) {
+    const thought = "Vision service is not available or no camera is connected.";
+    const text = "I cannot capture an image right now. No camera is available.";
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: false,
+      text: "Vision service unavailable - cannot capture image",
+      values: {
+        success: false,
+        visionAvailable: false,
+        error: "Vision service not available"
+      },
+      data: {
+        actionName: "VISION",
+        op: "capture",
+        error: "Vision service not available or no camera connected"
       }
-      const thought = `Analyzed the visual scene at ${timestamp}.`;
-      const text = description;
-      await saveExecutionRecord(runtime, message, thought, text, ["DESCRIBE_SCENE"]);
+    };
+  }
+  try {
+    const imageBuffer = await Promise.race([
+      visionService.captureImage(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("vision capture timed out")), VISION_ACTION_TIMEOUT_MS))
+    ]);
+    const cameraInfo = visionService.getCameraInfo();
+    if (!imageBuffer) {
+      const thought2 = "Failed to capture image from camera.";
+      const text2 = "I could not capture an image from the camera. Please try again.";
+      await saveExecutionRecord(runtime, message, thought2, text2, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["DESCRIBE_SCENE"]
-        });
+        await callback({ thought: thought2, text: text2, actions: ["VISION"] });
       }
       return {
-        success: true,
-        text: description,
+        success: false,
+        text: "Failed to capture image from camera",
         values: {
-          success: true,
+          success: false,
           visionAvailable: true,
-          sceneAnalyzed: true,
-          peopleCount,
-          objectCount,
-          cameraName: cameraInfo?.name || undefined,
-          sceneChanged: scene.sceneChanged,
-          changePercentage: scene.changePercentage
+          captureSuccess: false
         },
         data: {
-          actionName: "DESCRIBE_SCENE",
-          sceneTimestamp: scene.timestamp,
-          sceneDescription: scene.description,
-          sceneChanged: scene.sceneChanged,
-          changePercentage: scene.changePercentage,
-          audioTranscription: scene.audioTranscription || undefined,
-          objectCount: scene.objects.length,
-          peopleCount: scene.people.length,
+          actionName: "VISION",
+          op: "capture",
+          error: "Camera capture failed",
           cameraInfo: cameraInfo ? {
             id: cameraInfo.id,
             name: cameraInfo.name,
             connected: cameraInfo.connected
-          } : undefined,
-          timestamp,
-          description
+          } : undefined
         }
       };
-    } catch (error) {
-      logger.error("[describeSceneAction] Error analyzing scene:", error instanceof Error ? error.message : String(error));
-      const thought = "An error occurred while trying to analyze the visual scene.";
-      const text = `Error analyzing scene: ${error instanceof Error ? error.message : String(error)}`;
-      await saveExecutionRecord(runtime, message, thought, text, ["DESCRIBE_SCENE"]);
+    }
+    const attachmentId = createUniqueUuid(runtime, `capture-${Date.now()}`);
+    const timestamp = new Date().toISOString();
+    const imageAttachment = {
+      id: attachmentId,
+      title: `Camera Capture - ${timestamp}`,
+      contentType: ContentType.IMAGE,
+      source: `camera:${cameraInfo?.name || "unknown"}`,
+      url: `data:image/jpeg;base64,${imageBuffer.toString("base64")}`
+    };
+    const thought = `Captured an image from camera "${cameraInfo?.name}".`;
+    const text = `I've captured an image from the camera at ${timestamp}.`;
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"], [imageAttachment]);
+    if (callback) {
+      await callback({
+        thought,
+        text,
+        actions: ["VISION"],
+        attachments: [imageAttachment]
+      });
+    }
+    return {
+      success: true,
+      text: `I've captured an image from the camera at ${timestamp}.`,
+      values: {
+        success: true,
+        visionAvailable: true,
+        captureSuccess: true,
+        cameraName: cameraInfo?.name || undefined,
+        timestamp
+      },
+      data: {
+        actionName: "VISION",
+        op: "capture",
+        imageAttachment: {
+          id: imageAttachment.id,
+          title: imageAttachment.title,
+          contentType: imageAttachment.contentType,
+          source: imageAttachment.source,
+          url: imageAttachment.url
+        },
+        cameraInfo: cameraInfo ? {
+          id: cameraInfo.id,
+          name: cameraInfo.name,
+          connected: cameraInfo.connected
+        } : undefined,
+        timestamp
+      }
+    };
+  } catch (error) {
+    logger.error("[VISION/capture] Error capturing image:", error);
+    const thought = "An error occurred while trying to capture an image.";
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const text = `Error capturing image: ${errorMessage}`;
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: false,
+      text: "Error capturing image",
+      values: {
+        success: false,
+        visionAvailable: true,
+        error: true,
+        errorMessage
+      },
+      data: {
+        actionName: "VISION",
+        op: "capture",
+        error: errorMessage,
+        errorType: "capture_error"
+      }
+    };
+  }
+}
+async function runSetMode(runtime, message, options, callback) {
+  const visionService = runtime.getService("VISION");
+  if (!visionService) {
+    const thought = "Vision service is not available.";
+    const text = "I cannot change vision mode because the vision service is not available.";
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: false,
+      text,
+      data: { actionName: "VISION", op: "set_mode" }
+    };
+  }
+  try {
+    const explicitMode = typeof options.mode === "string" ? options.mode.toLowerCase() : "";
+    const messageText = explicitMode || message.content.text?.toLowerCase() || "";
+    let newMode = null;
+    if (messageText.includes("off") || messageText.includes("disable")) {
+      newMode = "OFF" /* OFF */;
+    } else if (messageText.includes("both")) {
+      newMode = "BOTH" /* BOTH */;
+    } else if (messageText.includes("screen")) {
+      newMode = "SCREEN" /* SCREEN */;
+    } else if (messageText.includes("camera")) {
+      newMode = "CAMERA" /* CAMERA */;
+    }
+    if (!newMode) {
+      const thought2 = "Could not determine the desired vision mode from the message.";
+      const text2 = "Please specify the vision mode: OFF, CAMERA, SCREEN, or BOTH.";
+      await saveExecutionRecord(runtime, message, thought2, text2, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["DESCRIBE_SCENE"]
-        });
+        await callback({ thought: thought2, text: text2, actions: ["VISION"] });
       }
-      const errorMessage = error instanceof Error ? error.message : String(error);
       return {
         success: false,
-        text: "Error analyzing scene",
-        values: {
-          success: false,
-          visionAvailable: true,
-          error: true,
-          errorMessage
-        },
-        data: {
-          actionName: "DESCRIBE_SCENE",
-          error: errorMessage,
-          errorType: "analysis_error"
-        }
+        text: text2,
+        data: { actionName: "VISION", op: "set_mode" }
       };
     }
-  },
-  examples: [
-    [
-      { name: "{{user}}", content: { text: "what do you see?" } },
-      {
-        name: "{{agent}}",
-        content: {
-          actions: ["DESCRIBE_SCENE"],
-          thought: "The user wants to know what I can see through my camera.",
-          text: "I see a room with a desk and computer setup. There are 2 people, one is sitting and one is standing."
-        }
-      }
-    ],
-    [
-      { name: "{{user}}", content: { text: "describe the scene and then take a photo" } },
-      {
-        name: "{{agent}}",
-        content: {
-          actions: ["DESCRIBE_SCENE", "CAPTURE_IMAGE"],
-          thought: "I should first analyze the scene, then capture an image for the user.",
-          text: "I can see 3 people in an office setting. Let me capture this scene for you."
-        }
-      }
-    ]
-  ]
-};
-var captureImageAction = {
-  name: "CAPTURE_IMAGE",
-  similes: ["TAKE_PHOTO", "SCREENSHOT", "CAPTURE_FRAME", "TAKE_PICTURE"],
-  description: "Captures the current frame from the camera and saves it as an image attachment. Returns image data with camera info and timestamp for action chaining. Can be combined with DESCRIBE_SCENE for analysis or NAME_ENTITY for identification workflows.",
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avVisionService = runtime?.getService?.("VISION");
-    const __avLegacyContextOk = Boolean(__avVisionService && typeof __avVisionService.isActive === "function" && __avVisionService.isActive());
-    const __avKeywords = ["capture", "image"];
-    const __avKeywordOk = __avKeywords.length > 0 && (__avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || __avLegacyContextOk);
-    const __avRegex = new RegExp("\\b(?:capture|image)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const visionService = runtime2.getService("VISION");
-      return !!visionService && visionService.isActive();
+    const currentMode = visionService.getVisionMode();
+    await Promise.race([
+      visionService.setVisionMode(newMode),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("vision mode change timed out")), VISION_ACTION_TIMEOUT_MS))
+    ]);
+    const thought = `Changed vision mode from ${currentMode} to ${newMode}.`;
+    let text = "";
+    switch (newMode) {
+      case "OFF" /* OFF */:
+        text = "Vision has been disabled. I will no longer process visual input.";
+        break;
+      case "CAMERA" /* CAMERA */:
+        text = "Vision mode set to CAMERA only. I will process input from the camera.";
+        break;
+      case "SCREEN" /* SCREEN */:
+        text = "Vision mode set to SCREEN only. I will analyze what's on your screen.";
+        break;
+      case "BOTH" /* BOTH */:
+        text = "Vision mode set to BOTH. I will process input from both camera and screen.";
+        break;
+    }
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: true,
+      text,
+      values: { visionMode: newMode },
+      data: { actionName: "VISION", op: "set_mode", visionMode: newMode }
     };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
+  } catch (error) {
+    logger.error("[VISION/set_mode] Error changing vision mode:", error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const thought = "An error occurred while trying to change the vision mode.";
+    const text = `Error changing vision mode: ${errorMessage}`;
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
     }
-  },
-  handler: async (runtime, message, _state, _options, callback, _responses) => {
+    return {
+      success: false,
+      text,
+      error: errorMessage,
+      data: { actionName: "VISION", op: "set_mode" }
+    };
+  }
+}
+async function runNameEntity(runtime, message, options, callback) {
+  try {
     const visionService = runtime.getService("VISION");
-    if (!visionService || !visionService.isActive()) {
-      const thought = "Vision service is not available or no camera is connected.";
-      const text = "I cannot capture an image right now. No camera is available.";
-      await saveExecutionRecord(runtime, message, thought, text, ["CAPTURE_IMAGE"]);
+    if (!visionService) {
+      const thought = "Vision service is not available.";
+      const text = "I cannot name entities because the vision service is not available.";
+      await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["CAPTURE_IMAGE"]
-        });
+        await callback({ thought, text, actions: ["VISION"] });
       }
       return {
         success: false,
-        text: "Vision service unavailable - cannot capture image",
-        values: {
-          success: false,
-          visionAvailable: false,
-          error: "Vision service not available"
-        },
-        data: {
-          actionName: "CAPTURE_IMAGE",
-          error: "Vision service not available or no camera connected"
-        }
+        text,
+        data: { actionName: "VISION", op: "name_entity" }
       };
     }
-    try {
-      const imageBuffer = await visionService.captureImage();
-      const cameraInfo = visionService.getCameraInfo();
-      if (!imageBuffer) {
-        const thought2 = "Failed to capture image from camera.";
-        const text2 = "I could not capture an image from the camera. Please try again.";
-        await saveExecutionRecord(runtime, message, thought2, text2, ["CAPTURE_IMAGE"]);
-        if (callback) {
-          await callback({
-            thought: thought2,
-            text: text2,
-            actions: ["CAPTURE_IMAGE"]
-          });
-        }
-        return {
-          success: false,
-          text: "Failed to capture image from camera",
-          values: {
-            success: false,
-            visionAvailable: true,
-            captureSuccess: false
-          },
-          data: {
-            actionName: "CAPTURE_IMAGE",
-            error: "Camera capture failed",
-            cameraInfo: cameraInfo ? {
-              id: cameraInfo.id,
-              name: cameraInfo.name,
-              connected: cameraInfo.connected
-            } : undefined
-          }
-        };
-      }
-      const attachmentId = createUniqueUuid(runtime, `capture-${Date.now()}`);
-      const timestamp = new Date().toISOString();
-      const imageAttachment = {
-        id: attachmentId,
-        title: `Camera Capture - ${timestamp}`,
-        contentType: ContentType.IMAGE,
-        source: `camera:${cameraInfo?.name || "unknown"}`,
-        url: `data:image/jpeg;base64,${imageBuffer.toString("base64")}`
-      };
-      const thought = `Captured an image from camera "${cameraInfo?.name}".`;
-      const text = `I've captured an image from the camera at ${timestamp}.`;
-      await saveExecutionRecord(runtime, message, thought, text, ["CAPTURE_IMAGE"], [imageAttachment]);
+    const scene = await withVisionTimeout(visionService.getSceneDescription(), "vision scene description");
+    if (!scene || scene.people.length === 0) {
+      const thought = "No people visible to name.";
+      const text = "I don't see any people in the current scene to name.";
+      await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["CAPTURE_IMAGE"],
-          attachments: [imageAttachment]
-        });
+        await callback({ thought, text, actions: ["VISION"] });
       }
       return {
-        success: true,
-        text: `I've captured an image from the camera at ${timestamp}.`,
-        values: {
-          success: true,
-          visionAvailable: true,
-          captureSuccess: true,
-          cameraName: cameraInfo?.name || undefined,
-          timestamp
-        },
-        data: {
-          actionName: "CAPTURE_IMAGE",
-          imageAttachment: {
-            id: imageAttachment.id,
-            title: imageAttachment.title,
-            contentType: imageAttachment.contentType,
-            source: imageAttachment.source,
-            url: imageAttachment.url
-          },
-          cameraInfo: cameraInfo ? {
-            id: cameraInfo.id,
-            name: cameraInfo.name,
-            connected: cameraInfo.connected
-          } : undefined,
-          timestamp
-        }
+        success: false,
+        text,
+        data: { actionName: "VISION", op: "name_entity" }
       };
-    } catch (error) {
-      logger.error("[captureImageAction] Error capturing image:", error);
-      const thought = "An error occurred while trying to capture an image.";
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const text = `Error capturing image: ${errorMessage}`;
-      await saveExecutionRecord(runtime, message, thought, text, ["CAPTURE_IMAGE"]);
+    }
+    const messageText = message.content.text?.toLowerCase() || "";
+    const explicitName = typeof options.name === "string" ? options.name.trim() : "";
+    const nameMatch = explicitName ? [explicitName, explicitName] : messageText.match(/(?:named?|call(?:ed)?|is)\s+(\w+)/i);
+    if (!nameMatch) {
+      const thought = "Could not extract name from message.";
+      const text = `I couldn't understand what name to assign. Please say something like "The person is named Alice".`;
+      await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["CAPTURE_IMAGE"]
-        });
+        await callback({ thought, text, actions: ["VISION"] });
       }
       return {
         success: false,
-        text: "Error capturing image",
-        values: {
-          success: false,
-          visionAvailable: true,
-          error: true,
-          errorMessage
-        },
-        data: {
-          actionName: "CAPTURE_IMAGE",
-          error: errorMessage,
-          errorType: "capture_error"
-        }
+        text,
+        data: { actionName: "VISION", op: "name_entity" }
       };
     }
-  },
-  examples: [
-    [
-      { name: "{{user}}", content: { text: "describe what you see and take a photo" } },
-      {
-        name: "{{agent}}",
-        content: {
-          actions: ["DESCRIBE_SCENE", "CAPTURE_IMAGE"],
-          thought: "User wants scene analysis followed by image capture.",
-          text: "I can see 3 people in an office setting. Let me capture this scene for you."
-        }
-      }
-    ],
-    [
-      { name: "{{user}}", content: { text: "take a photo" } },
-      {
-        name: "{{agent}}",
-        content: {
-          actions: ["CAPTURE_IMAGE"],
-          thought: "The user wants me to capture an image from the camera.",
-          text: "I've captured an image from the camera."
-        }
-      }
-    ],
-    [
-      { name: "{{user}}", content: { text: "capture the current scene" } },
-      {
-        name: "{{agent}}",
-        content: {
-          actions: ["CAPTURE_IMAGE"]
-        }
-      }
-    ]
-  ]
-};
-var setVisionModeAction = {
-  name: "SET_VISION_MODE",
-  description: "Set the vision mode to OFF, CAMERA, SCREEN, or BOTH",
-  similes: [
-    "change vision to {mode}",
-    "set vision mode {mode}",
-    "switch to {mode} vision",
-    "turn vision {mode}",
-    "use {mode} vision",
-    "enable {mode} vision",
-    "disable vision"
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avLegacyContextOk = Boolean(runtime?.getService?.("VISION"));
-    const __avKeywords = ["set", "vision", "mode"];
-    const __avKeywordOk = __avKeywords.length > 0 && (__avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || __avLegacyContextOk);
-    const __avRegex = new RegExp("\\b(?:set|vision|mode)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const visionService = runtime2.getService("VISION");
-      return visionService !== null;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  handler: async (runtime, message, _state, _options, callback, _responses) => {
-    const visionService = runtime.getService("VISION");
-    if (!visionService) {
-      const thought = "Vision service is not available.";
-      const text = "I cannot change vision mode because the vision service is not available.";
-      await saveExecutionRecord(runtime, message, thought, text, ["SET_VISION_MODE"]);
+    const name = nameMatch[1];
+    const entityTracker = visionService.getEntityTracker();
+    await entityTracker.updateEntities(scene.objects.slice(0, MAX_VISION_ENTITIES), scene.people.slice(0, MAX_VISION_ENTITIES), undefined, runtime);
+    const activeEntities = entityTracker.getActiveEntities();
+    const people = activeEntities.filter((e) => e.entityType === "person");
+    if (people.length === 0) {
+      const thought = "No tracked people found.";
+      const text = "I can see someone but haven't established tracking yet. Please try again in a moment.";
+      await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["SET_VISION_MODE"]
-        });
+        await callback({ thought, text, actions: ["VISION"] });
       }
       return {
         success: false,
-        text
+        text,
+        data: { actionName: "VISION", op: "name_entity" }
       };
     }
-    try {
-      const messageText = message.content.text?.toLowerCase() || "";
-      let newMode = null;
-      if (messageText.includes("off") || messageText.includes("disable")) {
-        newMode = "OFF" /* OFF */;
-      } else if (messageText.includes("both")) {
-        newMode = "BOTH" /* BOTH */;
-      } else if (messageText.includes("screen")) {
-        newMode = "SCREEN" /* SCREEN */;
-      } else if (messageText.includes("camera")) {
-        newMode = "CAMERA" /* CAMERA */;
-      }
-      if (!newMode) {
-        const thought2 = "Could not determine the desired vision mode from the message.";
-        const text2 = "Please specify the vision mode: OFF, CAMERA, SCREEN, or BOTH.";
-        await saveExecutionRecord(runtime, message, thought2, text2, ["SET_VISION_MODE"]);
-        if (callback) {
-          await callback({
-            thought: thought2,
-            text: text2,
-            actions: ["SET_VISION_MODE"]
-          });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      const currentMode = visionService.getVisionMode();
-      await visionService.setVisionMode(newMode);
-      const thought = `Changed vision mode from ${currentMode} to ${newMode}.`;
-      let text = "";
-      switch (newMode) {
-        case "OFF" /* OFF */:
-          text = "Vision has been disabled. I will no longer process visual input.";
-          break;
-        case "CAMERA" /* CAMERA */:
-          text = "Vision mode set to CAMERA only. I will process input from the camera.";
-          break;
-        case "SCREEN" /* SCREEN */:
-          text = "Vision mode set to SCREEN only. I will analyze what's on your screen.";
-          break;
-        case "BOTH" /* BOTH */:
-          text = "Vision mode set to BOTH. I will process input from both camera and screen.";
-          break;
-      }
-      await saveExecutionRecord(runtime, message, thought, text, ["SET_VISION_MODE"]);
+    let targetPerson = people[0];
+    if (people.length > 1) {
+      targetPerson = people.reduce((prev, curr) => {
+        const prevArea = prev.lastPosition.width * prev.lastPosition.height;
+        const currArea = curr.lastPosition.width * curr.lastPosition.height;
+        return currArea > prevArea ? curr : prev;
+      });
+    }
+    const success = entityTracker.assignNameToEntity(targetPerson.id, name);
+    if (success) {
+      const thought = `Named entity "${name}" and associated with person in scene.`;
+      const text = `I've identified the person as ${name}. I'll remember them for future interactions.`;
+      await saveExecutionRecord(runtime, message, thought, text, ["VISION"], undefined);
       if (callback) {
         await callback({
           thought,
           text,
-          actions: ["SET_VISION_MODE"]
+          actions: ["VISION"],
+          data: { entityId: targetPerson.id, name }
         });
       }
+      logger.info(`[VISION/name_entity] Assigned name "${name}" to entity ${targetPerson.id}`);
       return {
         success: true,
         text,
-        values: {
-          visionMode: newMode
+        values: { entityId: targetPerson.id, name },
+        data: {
+          actionName: "VISION",
+          op: "name_entity",
+          entityId: targetPerson.id,
+          name
         }
       };
-    } catch (error) {
-      logger.error("[setVisionModeAction] Error changing vision mode:", error);
-      const thought = "An error occurred while trying to change the vision mode.";
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const text = `Error changing vision mode: ${errorMessage}`;
-      await saveExecutionRecord(runtime, message, thought, text, ["SET_VISION_MODE"]);
+    } else {
+      const thought = "Failed to assign name to entity.";
+      const text = "There was an error assigning the name. Please try again.";
+      await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
       if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["SET_VISION_MODE"]
-        });
+        await callback({ thought, text, actions: ["VISION"] });
       }
       return {
         success: false,
         text,
-        error: errorMessage
+        data: { actionName: "VISION", op: "name_entity" }
       };
     }
-  },
-  examples: [
-    [
-      { name: "user", content: { text: "set vision mode to screen" } },
-      {
-        name: "agent",
-        content: {
-          actions: ["SET_VISION_MODE"],
-          thought: "The user wants to switch to screen vision mode.",
-          text: "Vision mode set to SCREEN only. I will analyze what's on your screen."
-        }
-      }
-    ],
-    [
-      { name: "user", content: { text: "enable both camera and screen vision" } },
-      {
-        name: "agent",
-        content: {
-          actions: ["SET_VISION_MODE"],
-          thought: "The user wants to enable both vision inputs.",
-          text: "Vision mode set to BOTH. I will process input from both camera and screen."
-        }
-      }
-    ],
-    [
-      { name: "user", content: { text: "turn off vision" } },
-      {
-        name: "agent",
-        content: {
-          actions: ["SET_VISION_MODE"],
-          thought: "The user wants to disable vision.",
-          text: "Vision has been disabled. I will no longer process visual input."
-        }
-      }
-    ]
-  ]
-};
-var nameEntityAction = {
-  name: "NAME_ENTITY",
-  description: "Assign a name to a person or object currently visible in the camera view",
-  similes: [
-    "call the person {name}",
-    "the person in front is {name}",
-    "name the person {name}",
-    "that person is {name}",
-    "the object is a {name}",
-    "call that {name}"
-  ],
-  examples: [
-    [
-      {
-        name: "user",
-        content: {
-          text: "The person wearing the blue shirt is named Alice"
-        }
-      },
-      {
-        name: "agent",
-        content: {
-          text: "I've identified the person in the blue shirt as Alice. I'll remember them for future interactions.",
-          actions: ["NAME_ENTITY"]
-        }
-      }
-    ],
-    [
-      {
-        name: "user",
-        content: {
-          text: "Call the person on the left Bob"
-        }
-      },
-      {
-        name: "agent",
-        content: {
-          text: "I've named the person on the left as Bob. Their face profile has been updated.",
-          actions: ["NAME_ENTITY"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avVisionService = runtime?.getService?.("VISION");
-    const __avLegacyContextOk = Boolean(__avVisionService && typeof __avVisionService.isActive === "function" && __avVisionService.isActive());
-    const __avKeywords = ["name", "entity"];
-    const __avKeywordOk = __avKeywords.length > 0 && (__avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || __avLegacyContextOk);
-    const __avRegex = new RegExp("\\b(?:name|entity)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const visionService = runtime2.getService("VISION");
-      return visionService?.isActive() || false;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
+  } catch (error) {
+    logger.error("[VISION/name_entity] Error:", error);
+    const thought = "Failed to name entity.";
+    const text = `Sorry, I couldn't name the entity: ${error instanceof Error ? error.message : "Unknown error"}`;
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
     }
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    try {
-      const visionService = runtime.getService("VISION");
-      if (!visionService) {
-        const thought = "Vision service is not available.";
-        const text2 = "I cannot name entities because the vision service is not available.";
-        await saveExecutionRecord(runtime, message, thought, text2, ["NAME_ENTITY"]);
-        if (callback) {
-          await callback({ thought, text: text2, actions: ["NAME_ENTITY"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      const scene = await visionService.getSceneDescription();
-      if (!scene || scene.people.length === 0) {
-        const thought = "No people visible to name.";
-        const text2 = "I don't see any people in the current scene to name.";
-        await saveExecutionRecord(runtime, message, thought, text2, ["NAME_ENTITY"]);
-        if (callback) {
-          await callback({ thought, text: text2, actions: ["NAME_ENTITY"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      const text = message.content.text?.toLowerCase() || "";
-      const nameMatch = text.match(/(?:named?|call(?:ed)?|is)\s+(\w+)/i);
-      if (!nameMatch) {
-        const thought = "Could not extract name from message.";
-        const text2 = `I couldn't understand what name to assign. Please say something like "The person is named Alice".`;
-        await saveExecutionRecord(runtime, message, thought, text2, ["NAME_ENTITY"]);
-        if (callback) {
-          await callback({ thought, text: text2, actions: ["NAME_ENTITY"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      const name = nameMatch[1];
-      const _worldId = message.worldId || "default-world";
-      const entityTracker = visionService.getEntityTracker();
-      await entityTracker.updateEntities(scene.objects, scene.people, undefined, runtime);
-      const activeEntities = entityTracker.getActiveEntities();
-      const people = activeEntities.filter((e) => e.entityType === "person");
-      if (people.length === 0) {
-        const thought = "No tracked people found.";
-        const text2 = "I can see someone but haven't established tracking yet. Please try again in a moment.";
-        await saveExecutionRecord(runtime, message, thought, text2, ["NAME_ENTITY"]);
-        if (callback) {
-          await callback({ thought, text: text2, actions: ["NAME_ENTITY"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      let targetPerson = people[0];
-      if (people.length > 1) {
-        targetPerson = people.reduce((prev, curr) => {
-          const prevArea = prev.lastPosition.width * prev.lastPosition.height;
-          const currArea = curr.lastPosition.width * curr.lastPosition.height;
-          return currArea > prevArea ? curr : prev;
-        });
+    return {
+      success: false,
+      text,
+      error: error instanceof Error ? error.message : String(error),
+      data: { actionName: "VISION", op: "name_entity" }
+    };
+  }
+}
+async function runIdentifyPerson(runtime, message, callback) {
+  try {
+    const visionService = runtime.getService("VISION");
+    if (!visionService) {
+      const thought2 = "Vision service is not available.";
+      const text2 = "I cannot identify people because the vision service is not available.";
+      await saveExecutionRecord(runtime, message, thought2, text2, ["VISION"]);
+      if (callback) {
+        await callback({ thought: thought2, text: text2, actions: ["VISION"] });
       }
-      const success = entityTracker.assignNameToEntity(targetPerson.id, name);
-      if (success) {
-        const thought = `Named entity "${name}" and associated with person in scene.`;
-        const text2 = `I've identified the person as ${name}. I'll remember them for future interactions.`;
-        await saveExecutionRecord(runtime, message, thought, text2, ["NAME_ENTITY"], undefined);
-        if (callback) {
-          await callback({
-            thought,
-            text: text2,
-            actions: ["NAME_ENTITY"],
-            data: { entityId: targetPerson.id, name }
-          });
-        }
-        logger.info(`[NameEntityAction] Assigned name "${name}" to entity ${targetPerson.id}`);
-        return {
-          success: true,
-          text: text2,
-          values: {
-            entityId: targetPerson.id,
-            name
-          }
-        };
-      } else {
-        const thought = "Failed to assign name to entity.";
-        const text2 = "There was an error assigning the name. Please try again.";
-        await saveExecutionRecord(runtime, message, thought, text2, ["NAME_ENTITY"]);
-        if (callback) {
-          await callback({ thought, text: text2, actions: ["NAME_ENTITY"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
+      return {
+        success: false,
+        text: text2,
+        data: { actionName: "VISION", op: "identify_person" }
+      };
+    }
+    const scene = await withVisionTimeout(visionService.getSceneDescription(), "vision scene description");
+    if (!scene || scene.people.length === 0) {
+      const thought2 = "No people visible to identify.";
+      const text2 = "I don't see any people in the current scene.";
+      await saveExecutionRecord(runtime, message, thought2, text2, ["VISION"]);
+      if (callback) {
+        await callback({ thought: thought2, text: text2, actions: ["VISION"] });
       }
-    } catch (error) {
-      logger.error("[NameEntityAction] Error:", error);
-      const thought = "Failed to name entity.";
-      const text = `Sorry, I couldn't name the entity: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await saveExecutionRecord(runtime, message, thought, text, ["NAME_ENTITY"]);
+      return {
+        success: false,
+        text: text2,
+        data: { actionName: "VISION", op: "identify_person" }
+      };
+    }
+    const entityTracker = visionService.getEntityTracker();
+    await entityTracker.updateEntities(scene.objects.slice(0, MAX_VISION_ENTITIES), scene.people.slice(0, MAX_VISION_ENTITIES), undefined, runtime);
+    const activeEntities = entityTracker.getActiveEntities();
+    const people = activeEntities.filter((e) => e.entityType === "person");
+    if (people.length === 0) {
+      const thought2 = "No tracked people found.";
+      const text2 = "I can see someone but I'm still processing their identity.";
+      await saveExecutionRecord(runtime, message, thought2, text2, ["VISION"]);
       if (callback) {
-        await callback({ thought, text, actions: ["NAME_ENTITY"] });
+        await callback({ thought: thought2, text: text2, actions: ["VISION"] });
       }
       return {
         success: false,
-        text,
-        error: error instanceof Error ? error.message : String(error)
+        text: text2,
+        data: { actionName: "VISION", op: "identify_person" }
       };
     }
-  }
-};
-var identifyPersonAction = {
-  name: "IDENTIFY_PERSON",
-  description: "Identify a person in view if they have been seen before",
-  similes: [
-    "who is that",
-    "who is the person",
-    "identify the person",
-    "do you recognize them",
-    "have you seen them before"
-  ],
-  examples: [
-    [
-      {
-        name: "user",
-        content: {
-          text: "Who is the person in front of you?"
+    let recognizedCount = 0;
+    let unknownCount = 0;
+    const identifications = [];
+    for (const person of people) {
+      const name = person.attributes.name;
+      const duration = Date.now() - person.firstSeen;
+      const durationStr = duration < 60000 ? `${Math.round(duration / 1000)} seconds` : `${Math.round(duration / 60000)} minutes`;
+      if (name) {
+        recognizedCount++;
+        const personInfo = `I can see ${name}. They've been here for ${durationStr}.`;
+        identifications.push(personInfo);
+        if (person.appearances.length > 5) {
+          identifications.push("I've been tracking them consistently.");
         }
-      },
-      {
-        name: "agent",
-        content: {
-          text: "That's Alice. I last saw her about 5 minutes ago. She's been here for the past 20 minutes.",
-          actions: ["IDENTIFY_PERSON"]
+      } else {
+        unknownCount++;
+        const personInfo = `I see an unidentified person who has been here for ${durationStr}.`;
+        identifications.push(personInfo);
+        if (person.attributes.faceId) {
+          identifications.push("I've captured their face profile but they haven't been named yet.");
         }
       }
-    ]
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avVisionService = runtime?.getService?.("VISION");
-    const __avLegacyContextOk = Boolean(__avVisionService && typeof __avVisionService.isActive === "function" && __avVisionService.isActive());
-    const __avKeywords = ["identify", "person"];
-    const __avKeywordOk = __avKeywords.length > 0 && (__avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || __avLegacyContextOk);
-    const __avRegex = new RegExp("\\b(?:identify|person)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const visionService = runtime2.getService("VISION");
-      return visionService?.isActive() || false;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
     }
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    try {
-      const visionService = runtime.getService("VISION");
-      if (!visionService) {
-        const thought2 = "Vision service is not available.";
-        const text2 = "I cannot identify people because the vision service is not available.";
-        await saveExecutionRecord(runtime, message, thought2, text2, ["IDENTIFY_PERSON"]);
-        if (callback) {
-          await callback({ thought: thought2, text: text2, actions: ["IDENTIFY_PERSON"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      const scene = await visionService.getSceneDescription();
-      if (!scene || scene.people.length === 0) {
-        const thought2 = "No people visible to identify.";
-        const text2 = "I don't see any people in the current scene.";
-        await saveExecutionRecord(runtime, message, thought2, text2, ["IDENTIFY_PERSON"]);
-        if (callback) {
-          await callback({ thought: thought2, text: text2, actions: ["IDENTIFY_PERSON"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      const _worldId = message.worldId || "default-world";
-      const entityTracker = visionService.getEntityTracker();
-      await entityTracker.updateEntities(scene.objects, scene.people, undefined, runtime);
-      const activeEntities = entityTracker.getActiveEntities();
-      const people = activeEntities.filter((e) => e.entityType === "person");
-      if (people.length === 0) {
-        const thought2 = "No tracked people found.";
-        const text2 = "I can see someone but I'm still processing their identity.";
-        await saveExecutionRecord(runtime, message, thought2, text2, ["IDENTIFY_PERSON"]);
-        if (callback) {
-          await callback({ thought: thought2, text: text2, actions: ["IDENTIFY_PERSON"] });
-        }
-        return {
-          success: false,
-          text: text2
-        };
-      }
-      const _responseText = "";
-      let recognizedCount = 0;
-      let unknownCount = 0;
-      const identifications = [];
-      for (const person of people) {
-        const name = person.attributes.name;
-        const duration = Date.now() - person.firstSeen;
-        const durationStr = duration < 60000 ? `${Math.round(duration / 1000)} seconds` : `${Math.round(duration / 60000)} minutes`;
-        if (name) {
-          recognizedCount++;
-          const personInfo = `I can see ${name}. They've been here for ${durationStr}.`;
-          identifications.push(personInfo);
-          if (person.appearances.length > 5) {
-            identifications.push("I've been tracking them consistently.");
-          }
-        } else {
-          unknownCount++;
-          const personInfo = `I see an unidentified person who has been here for ${durationStr}.`;
-          identifications.push(personInfo);
-          if (person.attributes.faceId) {
-            identifications.push("I've captured their face profile but they haven't been named yet.");
-          }
+    const recentlyLeft = entityTracker.getRecentlyLeft();
+    if (recentlyLeft.length > 0) {
+      identifications.push(`
+Recently departed:`);
+      for (const { entity, leftAt } of recentlyLeft) {
+        if (entity.entityType === "person" && entity.attributes.name) {
+          const timeAgo = Date.now() - leftAt;
+          const timeStr = timeAgo < 60000 ? `${Math.round(timeAgo / 1000)} seconds ago` : `${Math.round(timeAgo / 60000)} minutes ago`;
+          identifications.push(`${entity.attributes.name} left ${timeStr}.`);
         }
       }
-      const recentlyLeft = entityTracker.getRecentlyLeft();
-      if (recentlyLeft.length > 0) {
-        identifications.push(`
-Recently departed:`);
-        for (const { entity, leftAt } of recentlyLeft) {
-          if (entity.entityType === "person" && entity.attributes.name) {
-            const timeAgo = Date.now() - leftAt;
-            const timeStr = timeAgo < 60000 ? `${Math.round(timeAgo / 1000)} seconds ago` : `${Math.round(timeAgo / 60000)} minutes ago`;
-            identifications.push(`${entity.attributes.name} left ${timeStr}.`);
-          }
+    }
+    const thought = `Identified ${recognizedCount} known people and ${unknownCount} unknown people.`;
+    const text = identifications.join(" ");
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({
+        thought,
+        text,
+        actions: ["VISION"],
+        data: {
+          identifications: people.slice(0, MAX_VISION_ENTITIES).map((p) => ({
+            id: p.id,
+            entityType: p.entityType,
+            name: p.attributes.name || undefined
+          }))
         }
+      });
+    }
+    return {
+      success: true,
+      text,
+      values: { recognizedCount, unknownCount },
+      data: {
+        actionName: "VISION",
+        op: "identify_person",
+        recognizedCount,
+        unknownCount
       }
-      const thought = `Identified ${recognizedCount} known people and ${unknownCount} unknown people.`;
-      const text = identifications.join(" ");
-      await saveExecutionRecord(runtime, message, thought, text, ["IDENTIFY_PERSON"]);
-      if (callback) {
-        await callback({
-          thought,
-          text,
-          actions: ["IDENTIFY_PERSON"],
-          data: {
-            identifications: people.map((p) => ({
-              id: p.id,
-              entityType: p.entityType,
-              name: p.attributes.name || undefined
-            }))
-          }
-        });
+    };
+  } catch (error) {
+    logger.error("[VISION/identify_person] Error:", error);
+    const thought = "Failed to identify people.";
+    const text = `Sorry, I couldn't identify people: ${error instanceof Error ? error.message : "Unknown error"}`;
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: false,
+      text,
+      error: error instanceof Error ? error.message : String(error),
+      data: { actionName: "VISION", op: "identify_person" }
+    };
+  }
+}
+async function runTrackEntity(runtime, message, callback) {
+  try {
+    const visionService = runtime.getService("VISION");
+    if (!visionService) {
+      const thought2 = "Vision service is not available.";
+      const text = "I cannot track entities because the vision service is not available.";
+      await saveExecutionRecord(runtime, message, thought2, text, ["VISION"]);
+      if (callback) {
+        await callback({ thought: thought2, text, actions: ["VISION"] });
       }
       return {
-        success: true,
+        success: false,
         text,
-        values: {
-          recognizedCount,
-          unknownCount
-        }
+        data: { actionName: "VISION", op: "track_entity" }
       };
-    } catch (error) {
-      logger.error("[identifyPersonAction] Error:", error);
-      const thought = "Failed to identify people.";
-      const text = `Sorry, I couldn't identify people: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await saveExecutionRecord(runtime, message, thought, text, ["IDENTIFY_PERSON"]);
+    }
+    const scene = await withVisionTimeout(visionService.getSceneDescription(), "vision scene description");
+    if (!scene) {
+      const thought2 = "No scene available for tracking.";
+      const text = "I need a moment to process the visual scene before I can track entities.";
+      await saveExecutionRecord(runtime, message, thought2, text, ["VISION"]);
       if (callback) {
-        await callback({ thought, text, actions: ["IDENTIFY_PERSON"] });
+        await callback({ thought: thought2, text, actions: ["VISION"] });
       }
       return {
         success: false,
         text,
-        error: error instanceof Error ? error.message : String(error)
+        data: { actionName: "VISION", op: "track_entity" }
       };
     }
+    const entityTracker = visionService.getEntityTracker();
+    await entityTracker.updateEntities(scene.objects.slice(0, MAX_VISION_ENTITIES), scene.people.slice(0, MAX_VISION_ENTITIES), undefined, runtime);
+    const stats = entityTracker.getStatistics();
+    const thought = `Tracking ${stats.activeEntities} entities in the scene.`;
+    const summary = [
+      `I'm now tracking ${stats.activeEntities} entities in the scene`,
+      `(${stats.people} people, ${stats.objects} objects).`,
+      "The visual tracking system will maintain persistent IDs for all entities",
+      "and notify you of significant changes."
+    ];
+    const responseText = summary.join(" ");
+    await saveExecutionRecord(runtime, message, thought, responseText, [
+      "VISION"
+    ]);
+    if (callback) {
+      await callback({
+        thought,
+        text: responseText,
+        actions: ["VISION"],
+        data: { entities: stats.activeEntities }
+      });
+    }
+    logger.info(`[VISION/track_entity] Tracking ${stats.activeEntities} entities`);
+    return {
+      success: true,
+      text: responseText,
+      values: {
+        activeEntities: stats.activeEntities,
+        people: stats.people,
+        objects: stats.objects
+      },
+      data: {
+        actionName: "VISION",
+        op: "track_entity",
+        activeEntities: stats.activeEntities,
+        people: stats.people,
+        objects: stats.objects
+      }
+    };
+  } catch (error) {
+    logger.error("[VISION/track_entity] Error:", error);
+    const thought = "Failed to track entities.";
+    const text = `Sorry, I couldn't track entities: ${error instanceof Error ? error.message : "Unknown error"}`;
+    await saveExecutionRecord(runtime, message, thought, text, ["VISION"]);
+    if (callback) {
+      await callback({ thought, text, actions: ["VISION"] });
+    }
+    return {
+      success: false,
+      text,
+      error: error instanceof Error ? error.message : String(error),
+      data: { actionName: "VISION", op: "track_entity" }
+    };
   }
-};
-var trackEntityAction = {
-  name: "TRACK_ENTITY",
-  description: "Start tracking a specific person or object in view",
+}
+var visionAction = {
+  name: "VISION",
+  contexts: [...ALL_VISION_CONTEXTS],
+  contextGate: { anyOf: [...ALL_VISION_CONTEXTS] },
+  roleGate: { minRole: "USER" },
   similes: [
-    "track the {description}",
-    "follow the {description}",
-    "keep an eye on the {description}",
-    "watch the {description}"
+    "DESCRIBE_SCENE",
+    "CAPTURE_IMAGE",
+    "SET_VISION_MODE",
+    "NAME_ENTITY",
+    "IDENTIFY_PERSON",
+    "TRACK_ENTITY",
+    "ANALYZE_SCENE",
+    "WHAT_DO_YOU_SEE",
+    "VISION_CHECK",
+    "LOOK_AROUND",
+    "TAKE_PHOTO",
+    "SCREENSHOT",
+    "CAPTURE_FRAME",
+    "TAKE_PICTURE"
+  ],
+  description: "Camera and screen vision: describe the current scene, capture an image, switch vision mode (off/camera/screen/both), name a visible entity, identify a person, or start tracking an entity. The op is inferred from the message text when not explicitly provided.",
+  descriptionCompressed: "Vision: describe / capture / set_mode / name_entity / identify_person / track_entity.",
+  parameters: [
+    {
+      name: "subaction",
+      description: "Operation to perform: describe, capture, set_mode, name_entity, identify_person, or track_entity. Inferred from message text when omitted.",
+      required: false,
+      schema: { type: "string", enum: [...VISION_OPS] }
+    },
+    {
+      name: "detailLevel",
+      description: "For op=describe: 'summary' to omit object/person breakdowns, 'detailed' for the full breakdown.",
+      required: false,
+      schema: {
+        type: "string",
+        enum: ["summary", "detailed"],
+        default: "detailed"
+      }
+    },
+    {
+      name: "mode",
+      description: "For op=set_mode: vision mode to set: off, camera, screen, or both.",
+      required: false,
+      schema: { type: "string", enum: ["off", "camera", "screen", "both"] }
+    },
+    {
+      name: "name",
+      description: "For op=name_entity: the name to assign to the most relevant visible person or object.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "targetHint",
+      description: "For op=name_entity or op=identify_person: optional phrase describing which visible entity to focus on.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "description",
+      description: "For op=track_entity: optional description of the visible entity to prioritize for tracking.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "includeUnknown",
+      description: "For op=identify_person: whether to mention unidentified people in the response.",
+      required: false,
+      schema: { type: "boolean", default: true }
+    }
   ],
+  validate: async (runtime, _message, state, options) => {
+    if (!visionServiceIsActive(runtime)) {
+      const visionService = runtime.getService("VISION");
+      if (!visionService)
+        return false;
+    }
+    const params = readActionParams(options);
+    return selectedContextMatches(state, ALL_VISION_CONTEXTS) || typeof params.op === "string";
+  },
+  handler: async (runtime, message, _state, _options, callback, _responses) => {
+    const params = readActionParams(_options);
+    const explicitOp = normalizeOp(params.op ?? params.subaction);
+    const inferredOp = explicitOp ?? inferOpFromMessage(message.content?.text ?? "");
+    if (!inferredOp) {
+      const text = `VISION could not determine the operation. Specify one of: ${VISION_OPS.join(", ")}.`;
+      if (callback) {
+        await callback({ text, actions: ["VISION"] });
+      }
+      return {
+        success: false,
+        text,
+        values: { error: "MISSING" },
+        data: {
+          actionName: "VISION",
+          availableOps: VISION_OPS
+        }
+      };
+    }
+    switch (inferredOp) {
+      case "describe":
+        return runDescribe(runtime, message, params, callback);
+      case "capture":
+        return runCapture(runtime, message, callback);
+      case "set_mode":
+        return runSetMode(runtime, message, params, callback);
+      case "name_entity":
+        return runNameEntity(runtime, message, params, callback);
+      case "identify_person":
+        return runIdentifyPerson(runtime, message, callback);
+      case "track_entity":
+        return runTrackEntity(runtime, message, callback);
+    }
+  },
   examples: [
     [
+      { name: "{{user}}", content: { text: "what do you see?" } },
       {
-        name: "user",
+        name: "{{agent}}",
         content: {
-          text: "Track the person wearing the red shirt"
+          actions: ["VISION"],
+          thought: "The user wants to know what I can see through my camera.",
+          text: "I see a room with a desk and computer setup. There are 2 people, one is sitting and one is standing."
         }
-      },
+      }
+    ],
+    [
+      { name: "{{user}}", content: { text: "take a photo" } },
       {
-        name: "agent",
+        name: "{{agent}}",
         content: {
-          text: "I'm now tracking the person in the red shirt. I'll notify you of any significant movements or if they leave the scene.",
-          actions: ["TRACK_ENTITY"]
+          actions: ["VISION"],
+          thought: "The user wants me to capture an image from the camera.",
+          text: "I've captured an image from the camera."
         }
       }
-    ]
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avVisionService = runtime?.getService?.("VISION");
-    const __avLegacyContextOk = Boolean(__avVisionService && typeof __avVisionService.isActive === "function" && __avVisionService.isActive());
-    const __avKeywords = ["track", "entity"];
-    const __avKeywordOk = __avKeywords.length > 0 && (__avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw)) || __avLegacyContextOk);
-    const __avRegex = new RegExp("\\b(?:track|entity)\\b", "i");
-    const __avRegexOk = __avRegex.test(__avText) || __avLegacyContextOk;
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const visionService = runtime2.getService("VISION");
-      return visionService?.isActive() || false;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    try {
-      const visionService = runtime.getService("VISION");
-      if (!visionService) {
-        const thought2 = "Vision service is not available.";
-        const text = "I cannot track entities because the vision service is not available.";
-        await saveExecutionRecord(runtime, message, thought2, text, ["TRACK_ENTITY"]);
-        if (callback) {
-          await callback({ thought: thought2, text, actions: ["TRACK_ENTITY"] });
-        }
-        return {
-          success: false,
-          text
-        };
+    ],
+    [
+      { name: "{{user}}", content: { text: "set vision mode to screen" } },
+      {
+        name: "{{agent}}",
+        content: {
+          actions: ["VISION"],
+          thought: "The user wants to switch to screen vision mode.",
+          text: "Vision mode set to SCREEN only. I will analyze what's on your screen."
+        }
       }
-      const scene = await visionService.getSceneDescription();
-      if (!scene) {
-        const thought2 = "No scene available for tracking.";
-        const text = "I need a moment to process the visual scene before I can track entities.";
-        await saveExecutionRecord(runtime, message, thought2, text, ["TRACK_ENTITY"]);
-        if (callback) {
-          await callback({ thought: thought2, text, actions: ["TRACK_ENTITY"] });
+    ],
+    [
+      {
+        name: "{{user}}",
+        content: { text: "the person wearing the blue shirt is named Alice" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          actions: ["VISION"],
+          text: "I've identified the person in the blue shirt as Alice. I'll remember them for future interactions."
         }
-        return {
-          success: false,
-          text
-        };
       }
-      const _text = message.content.text?.toLowerCase() || "";
-      const _worldId = message.worldId || "default-world";
-      const entityTracker = visionService.getEntityTracker();
-      await entityTracker.updateEntities(scene.objects, scene.people, undefined, runtime);
-      const stats = entityTracker.getStatistics();
-      const thought = `Tracking ${stats.activeEntities} entities in the scene.`;
-      const summary = [
-        `I'm now tracking ${stats.activeEntities} entities in the scene`,
-        `(${stats.people} people, ${stats.objects} objects).`,
-        "The visual tracking system will maintain persistent IDs for all entities",
-        "and notify you of significant changes."
-      ];
-      const responseText = summary.join(" ");
-      await saveExecutionRecord(runtime, message, thought, responseText, ["TRACK_ENTITY"]);
-      if (callback) {
-        await callback({
-          thought,
-          text: responseText,
-          actions: ["TRACK_ENTITY"],
-          data: { entities: stats.activeEntities }
-        });
+    ],
+    [
+      {
+        name: "{{user}}",
+        content: { text: "who is the person in front of you?" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          actions: ["VISION"],
+          text: "That's Alice. I last saw her about 5 minutes ago."
+        }
       }
-      logger.info(`[TrackEntityAction] Tracking ${stats.activeEntities} entities`);
-      return {
-        success: true,
-        text: responseText,
-        values: {
-          activeEntities: stats.activeEntities,
-          people: stats.people,
-          objects: stats.objects
+    ],
+    [
+      {
+        name: "{{user}}",
+        content: { text: "track the person wearing the red shirt" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          actions: ["VISION"],
+          text: "I'm now tracking the person in the red shirt."
         }
-      };
-    } catch (error) {
-      logger.error("[trackEntityAction] Error:", error);
-      const thought = "Failed to track entities.";
-      const text = `Sorry, I couldn't track entities: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await saveExecutionRecord(runtime, message, thought, text, ["TRACK_ENTITY"]);
-      if (callback) {
-        await callback({ thought, text, actions: ["TRACK_ENTITY"] });
       }
-      return {
-        success: false,
-        text,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
+    ]
+  ]
 };
 
 // src/provider.ts
 import {
-  addHeader,
   logger as logger2
 } from "@elizaos/core";
+var MAX_VISION_OBJECTS_IN_STATE = 50;
+var MAX_VISION_PEOPLE_IN_STATE = 25;
+var MAX_TRACKED_ENTITIES_IN_STATE = 25;
 var visionProvider = {
   name: "VISION_PERCEPTION",
   description: "Provides current visual perception data including scene description, detected objects, people, and entity tracking. This provider is always active and provides real-time visual awareness.",
   position: 99,
+  contexts: ["media", "browser"],
+  contextGate: { anyOf: ["media", "browser"] },
+  cacheStable: false,
+  cacheScope: "turn",
   dynamic: false,
   get: async (runtime, message, _state) => {
     const visionService = runtime.getService("VISION");
@@ -1160,201 +1237,231 @@ var visionProvider = {
           sceneDescription: "Vision service is not available.",
           cameraStatus: "No camera connected"
         },
-        text: addHeader("# Visual Perception", "Vision service is not available."),
+        text: JSON.stringify({
+          visual_perception: {
+            visionAvailable: false,
+            sceneDescription: "Vision service is not available.",
+            cameraStatus: "No camera connected"
+          }
+        }, null, 2),
         data: { hasVision: false }
       };
     }
-    const sceneDescription = await visionService.getEnhancedSceneDescription() || await visionService.getSceneDescription();
-    const cameraInfo = visionService.getCameraInfo();
-    const isActive = visionService.isActive();
-    const visionMode = visionService.getVisionMode();
-    const screenCapture = await visionService.getScreenCapture();
-    const _worldId = message.worldId || "default-world";
-    const entityTracker = visionService.getEntityTracker();
-    let entityData = null;
-    if (sceneDescription && entityTracker) {
-      await entityTracker.updateEntities(sceneDescription.objects, sceneDescription.people, undefined, runtime);
-      const activeEntities = entityTracker.getActiveEntities();
-      const recentlyLeft = entityTracker.getRecentlyLeft();
-      const stats = entityTracker.getStatistics();
-      entityData = {
-        activeEntities: activeEntities.map((e) => ({
-          id: e.id,
-          type: e.entityType,
-          name: e.attributes.name,
-          firstSeen: e.firstSeen,
-          duration: Date.now() - e.firstSeen,
-          position: e.lastPosition,
-          attributes: e.attributes
-        })),
-        recentlyLeft: recentlyLeft.map(({ entity, leftAt }) => ({
-          id: entity.id,
-          name: entity.attributes.name,
-          leftAt,
-          timeAgo: Date.now() - leftAt
-        })),
-        statistics: stats
-      };
-    }
-    let perceptionText = "";
-    let values = {};
-    let data = {};
-    if (!isActive) {
-      perceptionText = `Vision mode: ${visionMode}
+    try {
+      const sceneDescription = await visionService.getEnhancedSceneDescription() || await visionService.getSceneDescription();
+      const cameraInfo = visionService.getCameraInfo();
+      const isActive = visionService.isActive();
+      const visionMode = visionService.getVisionMode();
+      const screenCapture = await visionService.getScreenCapture();
+      const _worldId = message.worldId || "default-world";
+      const entityTracker = visionService.getEntityTracker();
+      let entityData = null;
+      if (sceneDescription && entityTracker) {
+        await entityTracker.updateEntities(sceneDescription.objects, sceneDescription.people, undefined, runtime);
+        const activeEntities = entityTracker.getActiveEntities();
+        const recentlyLeft = entityTracker.getRecentlyLeft();
+        const stats = entityTracker.getStatistics();
+        entityData = {
+          activeEntities: activeEntities.slice(0, MAX_TRACKED_ENTITIES_IN_STATE).map((e) => ({
+            id: e.id,
+            type: e.entityType,
+            name: e.attributes.name,
+            firstSeen: e.firstSeen,
+            duration: Date.now() - e.firstSeen,
+            position: e.lastPosition,
+            attributes: e.attributes
+          })),
+          recentlyLeft: recentlyLeft.slice(0, MAX_TRACKED_ENTITIES_IN_STATE).map(({ entity, leftAt }) => ({
+            id: entity.id,
+            name: entity.attributes.name,
+            leftAt,
+            timeAgo: Date.now() - leftAt
+          })),
+          statistics: stats
+        };
+      }
+      let perceptionText = "";
+      let values = {};
+      let data = {};
+      if (!isActive) {
+        perceptionText = `Vision mode: ${visionMode}
 `;
-      if (visionMode === "OFF") {
-        perceptionText += "Vision is disabled.";
+        if (visionMode === "OFF") {
+          perceptionText += "Vision is disabled.";
+        } else {
+          perceptionText += "Vision service is initializing...";
+        }
+        values = {
+          visionAvailable: false,
+          visionMode,
+          sceneDescription: "Vision not active",
+          cameraStatus: cameraInfo ? `Camera "${cameraInfo.name}" detected but not active` : "No camera"
+        };
       } else {
-        perceptionText += "Vision service is initializing...";
-      }
-      values = {
-        visionAvailable: false,
-        visionMode,
-        sceneDescription: "Vision not active",
-        cameraStatus: cameraInfo ? `Camera "${cameraInfo.name}" detected but not active` : "No camera"
-      };
-    } else {
-      perceptionText = `Vision mode: ${visionMode}
+        perceptionText = `Vision mode: ${visionMode}
 
 `;
-      if ((visionMode === "CAMERA" || visionMode === "BOTH") && sceneDescription) {
-        const ageInSeconds = (Date.now() - sceneDescription.timestamp) / 1000;
-        const secondsAgo = Math.round(ageInSeconds);
-        perceptionText += `Camera view (${secondsAgo}s ago):
+        if ((visionMode === "CAMERA" || visionMode === "BOTH") && sceneDescription) {
+          const ageInSeconds = (Date.now() - sceneDescription.timestamp) / 1000;
+          const secondsAgo = Math.round(ageInSeconds);
+          perceptionText += `Camera view (${secondsAgo}s ago):
 ${sceneDescription.description}`;
-        if (sceneDescription.people.length > 0) {
-          perceptionText += `
+          if (sceneDescription.people.length > 0) {
+            perceptionText += `
 
 People detected: ${sceneDescription.people.length}`;
-          const poses = sceneDescription.people.map((p) => p.pose).filter((p) => p !== "unknown");
-          const facings = sceneDescription.people.map((p) => p.facing).filter((f) => f !== "unknown");
-          if (poses.length > 0) {
-            const poseCounts = poses.reduce((acc, pose) => {
-              acc[pose] = (acc[pose] || 0) + 1;
-              return acc;
-            }, {});
-            perceptionText += `
+            const poses = sceneDescription.people.map((p) => p.pose).filter((p) => p !== "unknown");
+            const facings = sceneDescription.people.map((p) => p.facing).filter((f) => f !== "unknown");
+            if (poses.length > 0) {
+              const poseCounts = poses.reduce((acc, pose) => {
+                acc[pose] = (acc[pose] || 0) + 1;
+                return acc;
+              }, {});
+              perceptionText += `
   Poses: ${Object.entries(poseCounts).map(([pose, count]) => `${count} ${pose}`).join(", ")}`;
-          }
-          if (facings.length > 0) {
-            const facingCounts = facings.reduce((acc, facing) => {
-              acc[facing] = (acc[facing] || 0) + 1;
-              return acc;
-            }, {});
-            perceptionText += `
+            }
+            if (facings.length > 0) {
+              const facingCounts = facings.reduce((acc, facing) => {
+                acc[facing] = (acc[facing] || 0) + 1;
+                return acc;
+              }, {});
+              perceptionText += `
   Facing: ${Object.entries(facingCounts).map(([facing, count]) => `${count} facing ${facing}`).join(", ")}`;
+            }
           }
-        }
-        if (sceneDescription.objects.length > 0) {
-          const objectTypes = sceneDescription.objects.map((o) => o.type);
-          const uniqueObjects = [...new Set(objectTypes)];
-          perceptionText += `
+          if (sceneDescription.objects.length > 0) {
+            const objectTypes = sceneDescription.objects.slice(0, MAX_VISION_OBJECTS_IN_STATE).map((o) => o.type);
+            const uniqueObjects = [...new Set(objectTypes)];
+            perceptionText += `
 
 Objects detected: ${uniqueObjects.join(", ")}`;
-        }
-        if (sceneDescription.sceneChanged) {
-          perceptionText += `
+          }
+          if (sceneDescription.sceneChanged) {
+            perceptionText += `
 
 Scene change: ${sceneDescription.changePercentage.toFixed(1)}% of pixels changed`;
-        }
-        if (entityData) {
-          if (entityData.activeEntities.length > 0) {
-            perceptionText += `
+          }
+          if (entityData) {
+            if (entityData.activeEntities.length > 0) {
+              perceptionText += `
 
 Currently tracking:`;
-            for (const entity of entityData.activeEntities) {
-              const name = entity.name || `Unknown ${entity.type}`;
-              const duration = entity.duration < 60000 ? `${Math.round(entity.duration / 1000)}s` : `${Math.round(entity.duration / 60000)}m`;
-              perceptionText += `
+              for (const entity of entityData.activeEntities) {
+                const name = entity.name || `Unknown ${entity.type}`;
+                const duration = entity.duration < 60000 ? `${Math.round(entity.duration / 1000)}s` : `${Math.round(entity.duration / 60000)}m`;
+                perceptionText += `
 - ${name} (present for ${duration})`;
+              }
             }
-          }
-          if (entityData.recentlyLeft.length > 0) {
-            perceptionText += `
+            if (entityData.recentlyLeft.length > 0) {
+              perceptionText += `
 
 Recently left:`;
-            for (const departed of entityData.recentlyLeft) {
-              const name = departed.name || "Unknown person";
-              const timeStr = departed.timeAgo < 60000 ? `${Math.round(departed.timeAgo / 1000)}s ago` : `${Math.round(departed.timeAgo / 60000)}m ago`;
-              perceptionText += `
+              for (const departed of entityData.recentlyLeft) {
+                const name = departed.name || "Unknown person";
+                const timeStr = departed.timeAgo < 60000 ? `${Math.round(departed.timeAgo / 1000)}s ago` : `${Math.round(departed.timeAgo / 60000)}m ago`;
+                perceptionText += `
 - ${name} left ${timeStr}`;
+              }
             }
           }
         }
-      }
-      if ((visionMode === "SCREEN" || visionMode === "BOTH") && screenCapture) {
-        const screenAge = (Date.now() - screenCapture.timestamp) / 1000;
-        const screenSecondsAgo = Math.round(screenAge);
-        if (visionMode === "BOTH") {
-          perceptionText += `
+        if ((visionMode === "SCREEN" || visionMode === "BOTH") && screenCapture) {
+          const screenAge = (Date.now() - screenCapture.timestamp) / 1000;
+          const screenSecondsAgo = Math.round(screenAge);
+          if (visionMode === "BOTH") {
+            perceptionText += `
 
 ---
 
 `;
-        }
-        perceptionText += `Screen capture (${screenSecondsAgo}s ago):
+          }
+          perceptionText += `Screen capture (${screenSecondsAgo}s ago):
 `;
-        perceptionText += `Resolution: ${screenCapture.width}x${screenCapture.height}
+          perceptionText += `Resolution: ${screenCapture.width}x${screenCapture.height}
 `;
-        const enhanced = sceneDescription;
-        if (enhanced?.screenAnalysis) {
-          const tileAnalysis = enhanced.screenAnalysis.activeTile;
-          if (tileAnalysis) {
-            if (tileAnalysis.summary) {
-              perceptionText += `
+          const enhanced = sceneDescription;
+          if (enhanced?.screenAnalysis) {
+            const tileAnalysis = enhanced.screenAnalysis.activeTile;
+            if (tileAnalysis) {
+              if (tileAnalysis.summary) {
+                perceptionText += `
 Active area: ${tileAnalysis.summary}`;
-            }
-            if (tileAnalysis.text) {
-              perceptionText += `
+              }
+              if (tileAnalysis.text) {
+                perceptionText += `
 
 Visible text:
 "${tileAnalysis.text.substring(0, 200)}${tileAnalysis.text.length > 200 ? "..." : ""}"`;
-            }
-            if (tileAnalysis.objects && tileAnalysis.objects.length > 0) {
-              const uiElements = tileAnalysis.objects.map((o) => o.type || "unknown");
-              const uniqueElements = [...new Set(uiElements)];
-              perceptionText += `
+              }
+              if (tileAnalysis.objects && tileAnalysis.objects.length > 0) {
+                const uiElements = tileAnalysis.objects.map((o) => o.type || "unknown");
+                const uniqueElements = [...new Set(uiElements)];
+                perceptionText += `
 
 UI elements: ${uniqueElements.join(", ")}`;
+              }
             }
-          }
-          if (enhanced.screenAnalysis.focusedApp) {
-            perceptionText += `
+            if (enhanced.screenAnalysis.focusedApp) {
+              perceptionText += `
 
 Active application: ${enhanced.screenAnalysis.focusedApp}`;
+            }
           }
         }
+        values = {
+          visionAvailable: true,
+          visionMode,
+          sceneDescription: sceneDescription?.description || "Processing...",
+          cameraStatus: cameraInfo ? `Connected to ${cameraInfo.name}` : "No camera",
+          cameraId: cameraInfo?.id,
+          peopleCount: sceneDescription?.people.length || 0,
+          objectCount: sceneDescription?.objects.length || 0,
+          sceneAge: sceneDescription ? Math.round((Date.now() - sceneDescription.timestamp) / 1000) : null,
+          lastChange: sceneDescription?.sceneChanged ? sceneDescription.changePercentage : 0,
+          hasScreenCapture: !!screenCapture,
+          screenResolution: screenCapture ? `${screenCapture.width}x${screenCapture.height}` : null,
+          activeEntities: entityData?.activeEntities || [],
+          recentlyLeft: entityData?.recentlyLeft || [],
+          entityStatistics: entityData?.statistics || null
+        };
+        data = {
+          objects: sceneDescription?.objects.slice(0, MAX_VISION_OBJECTS_IN_STATE) || [],
+          people: sceneDescription?.people.slice(0, MAX_VISION_PEOPLE_IN_STATE) || [],
+          screenCapture: screenCapture || null,
+          enhancedData: sceneDescription?.screenAnalysis || null,
+          trackedEntities: entityData?.activeEntities || [],
+          worldState: entityData || null
+        };
       }
-      values = {
-        visionAvailable: true,
-        visionMode,
-        sceneDescription: sceneDescription?.description || "Processing...",
-        cameraStatus: cameraInfo ? `Connected to ${cameraInfo.name}` : "No camera",
-        cameraId: cameraInfo?.id,
-        peopleCount: sceneDescription?.people.length || 0,
-        objectCount: sceneDescription?.objects.length || 0,
-        sceneAge: sceneDescription ? Math.round((Date.now() - sceneDescription.timestamp) / 1000) : null,
-        lastChange: sceneDescription?.sceneChanged ? sceneDescription.changePercentage : 0,
-        hasScreenCapture: !!screenCapture,
-        screenResolution: screenCapture ? `${screenCapture.width}x${screenCapture.height}` : null,
-        activeEntities: entityData?.activeEntities || [],
-        recentlyLeft: entityData?.recentlyLeft || [],
-        entityStatistics: entityData?.statistics || null
+      return {
+        values,
+        text: JSON.stringify({
+          visual_perception: {
+            summary: perceptionText,
+            ...values
+          }
+        }, null, 2),
+        data
       };
-      data = {
-        objects: sceneDescription?.objects || [],
-        people: sceneDescription?.people || [],
-        screenCapture: screenCapture || null,
-        enhancedData: sceneDescription?.screenAnalysis || null,
-        trackedEntities: entityData?.activeEntities || [],
-        worldState: entityData || null
+    } catch (error) {
+      return {
+        values: {
+          visionAvailable: false,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        text: JSON.stringify({
+          visual_perception: {
+            visionAvailable: false,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }, null, 2),
+        data: {
+          hasVision: false,
+          error: error instanceof Error ? error.message : String(error)
+        }
       };
     }
-    return {
-      values,
-      text: addHeader("# Visual Perception", perceptionText),
-      data
-    };
   }
 };
 
@@ -1364,9 +1471,11 @@ import * as fs3 from "node:fs/promises";
 import * as path5 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import {
-  logger as logger14,
+  logger as logger15,
   ModelType as ModelType3,
-  Service
+  recordLlmCall,
+  Service,
+  withStandaloneTrajectory as withStandaloneTrajectory3
 } from "@elizaos/core";
 import sharp4 from "sharp";
 
@@ -1375,7 +1484,11 @@ import { exec } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { promisify } from "node:util";
-import { logger as logger3, ModelType } from "@elizaos/core";
+import {
+  logger as logger3,
+  ModelType,
+  withStandaloneTrajectory
+} from "@elizaos/core";
 var execAsync = promisify(exec);
 
 class AudioCaptureService {
@@ -1426,7 +1539,11 @@ class AudioCaptureService {
         await execAsync("where ffmpeg");
         return { available: true, tool: "ffmpeg" };
       }
-      return { available: false, tool: "none", message: "Unsupported platform" };
+      return {
+        available: false,
+        tool: "none",
+        message: "Unsupported platform"
+      };
     } catch (_error) {
       const toolName = platform === "darwin" ? "sox" : platform === "linux" ? "arecord" : "ffmpeg";
       const installCmd = platform === "darwin" ? "brew install sox" : platform === "linux" ? "sudo apt-get install alsa-utils" : "Download ffmpeg from ffmpeg.org";
@@ -1460,7 +1577,13 @@ class AudioCaptureService {
       await this.recordAudio(audioFile, this.config.transcriptionInterval / 1000);
       logger3.debug("[AudioCapture] Recording complete, transcribing...");
       const audioBuffer = await fs.readFile(audioFile);
-      const transcription = await this.runtime.useModel(ModelType.TRANSCRIPTION, audioBuffer);
+      const transcription = await withStandaloneTrajectory(this.runtime, {
+        source: "plugin-vision:audio-transcription",
+        metadata: {
+          modelType: ModelType.TRANSCRIPTION,
+          audioBytes: audioBuffer.byteLength
+        }
+      }, () => this.runtime.useModel(ModelType.TRANSCRIPTION, audioBuffer));
       await fs.unlink(audioFile).catch(() => {});
       if (transcription && typeof transcription === "string" && transcription.trim()) {
         logger3.info(`[AudioCapture] Transcribed: "${transcription}"`);
@@ -1583,7 +1706,11 @@ class AudioCaptureService {
 // src/audio-capture-stream.ts
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { logger as logger4, ModelType as ModelType2 } from "@elizaos/core";
+import {
+  logger as logger4,
+  ModelType as ModelType2,
+  withStandaloneTrajectory as withStandaloneTrajectory2
+} from "@elizaos/core";
 
 class StreamingAudioCaptureService extends EventEmitter {
   runtime;
@@ -1814,7 +1941,13 @@ class StreamingAudioCaptureService extends EventEmitter {
   async transcribeAudio(audioData) {
     try {
       const wavBuffer = this.rawToWav(audioData);
-      const result = await this.runtime.useModel(ModelType2.TRANSCRIPTION, wavBuffer);
+      const result = await withStandaloneTrajectory2(this.runtime, {
+        source: "plugin-vision:streaming-audio-transcription",
+        metadata: {
+          modelType: ModelType2.TRANSCRIPTION,
+          audioBytes: wavBuffer.byteLength
+        }
+      }, () => this.runtime.useModel(ModelType2.TRANSCRIPTION, wavBuffer));
       return result;
     } catch (error) {
       logger4.error("[StreamingAudio] Transcription failed:", error);
@@ -1904,7 +2037,10 @@ class StreamingAudioCaptureService extends EventEmitter {
 }
 
 // src/entity-tracker.ts
-import { createUniqueUuid as createUniqueUuid2, logger as logger5 } from "@elizaos/core";
+import {
+  createUniqueUuid as createUniqueUuid2,
+  logger as logger5
+} from "@elizaos/core";
 
 class EntityTracker {
   worldState;
@@ -3112,9 +3248,27 @@ class OCRService {
     logger10.debug("[OCR] Using fallback OCR implementation");
     const blocks = [];
     const mockTexts = [
-      { text: "File Edit View Window Help", x: 10, y: 5, width: 300, height: 20 },
-      { text: "Welcome to the application", x: 100, y: 100, width: 400, height: 40 },
-      { text: "Click here to continue", x: 200, y: 300, width: 200, height: 30 }
+      {
+        text: "File Edit View Window Help",
+        x: 10,
+        y: 5,
+        width: 300,
+        height: 20
+      },
+      {
+        text: "Welcome to the application",
+        x: 100,
+        y: 100,
+        width: 400,
+        height: 40
+      },
+      {
+        text: "Click here to continue",
+        x: 200,
+        y: 300,
+        width: 200,
+        height: 30
+      }
     ];
     for (const mock of mockTexts) {
       blocks.push({
@@ -3335,8 +3489,46 @@ class ScreenCaptureService {
   }
 }
 
-// src/vision-models.ts
+// src/test-input.ts
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { logger as logger12 } from "@elizaos/core";
+function getTestInputMode() {
+  const raw = (process.env.ELIZA_VISION_TEST_INPUT ?? "").trim().toLowerCase();
+  if (raw === "image")
+    return "image";
+  if (raw === "camera")
+    return "camera";
+  if (raw === "screen")
+    return "screen";
+  return "unset";
+}
+var FIXTURE_DEFAULT_REL = "test/fixtures/sample-scene.png";
+function resolveFixturePath() {
+  const fromEnv = process.env.ELIZA_VISION_TEST_FIXTURE;
+  if (fromEnv)
+    return resolve(fromEnv);
+  return resolve(process.cwd(), FIXTURE_DEFAULT_REL);
+}
+var cached = null;
+var cachedKey = null;
+function getTestImage() {
+  if (getTestInputMode() !== "image")
+    return null;
+  const path4 = resolveFixturePath();
+  if (cachedKey === path4 && cached)
+    return cached;
+  if (!existsSync(path4)) {
+    logger12.warn(`[plugin-vision] ELIZA_VISION_TEST_INPUT=image set but fixture not found at ${path4}.`);
+    return null;
+  }
+  cached = readFileSync(path4);
+  cachedKey = path4;
+  return cached;
+}
+
+// src/vision-models.ts
+import { logger as logger13 } from "@elizaos/core";
 var tf2 = null;
 var cocoSsd = null;
 var poseDetection = null;
@@ -3349,7 +3541,7 @@ async function loadTfModules() {
     poseDetection = await import("@tensorflow-models/pose-detection");
     return true;
   } catch (err) {
-    logger12.warn("[VisionModels] TensorFlow.js native addon not available — " + "falling back to description-based detection. Run `npm rebuild @tensorflow/tfjs-node --build-addon-from-source` to enable hardware-accelerated vision.");
+    logger13.warn("[VisionModels] TensorFlow.js native addon not available — " + "falling back to description-based detection. Run `npm rebuild @tensorflow/tfjs-node --build-addon-from-source` to enable hardware-accelerated vision.");
     return false;
   }
 }
@@ -3363,30 +3555,30 @@ class VisionModels {
     if (this.initialized) {
       return;
     }
-    logger12.info("[VisionModels] Initializing vision models...");
+    logger13.info("[VisionModels] Initializing vision models...");
     this.tfAvailable = await loadTfModules();
     if (!this.tfAvailable || !tf2 || !cocoSsd || !poseDetection) {
       this.initialized = true;
-      logger12.info("[VisionModels] Initialized without TensorFlow (fallback mode)");
+      logger13.info("[VisionModels] Initialized without TensorFlow (fallback mode)");
       return;
     }
     try {
       await tf2.ready();
-      logger12.info("[VisionModels] TensorFlow.js backend ready");
+      logger13.info("[VisionModels] TensorFlow.js backend ready");
       if (config.enableObjectDetection) {
         try {
-          logger12.info("[VisionModels] Loading COCO-SSD model...");
+          logger13.info("[VisionModels] Loading COCO-SSD model...");
           this.objectDetectionModel = await cocoSsd.load({
             base: "mobilenet_v2"
           });
-          logger12.info("[VisionModels] COCO-SSD model loaded");
+          logger13.info("[VisionModels] COCO-SSD model loaded");
         } catch (error) {
-          logger12.error("[VisionModels] Failed to load COCO-SSD model:", error);
+          logger13.error("[VisionModels] Failed to load COCO-SSD model:", error);
         }
       }
       if (config.enablePoseDetection) {
         try {
-          logger12.info("[VisionModels] Loading PoseNet model...");
+          logger13.info("[VisionModels] Loading PoseNet model...");
           const detectorConfig = {
             architecture: "MobileNetV1",
             outputStride: 16,
@@ -3394,15 +3586,15 @@ class VisionModels {
             multiplier: 0.75
           };
           this.poseDetector = await poseDetection.createDetector(poseDetection.SupportedModels.PoseNet, detectorConfig);
-          logger12.info("[VisionModels] PoseNet model loaded");
+          logger13.info("[VisionModels] PoseNet model loaded");
         } catch (error) {
-          logger12.error("[VisionModels] Failed to load PoseNet model:", error);
+          logger13.error("[VisionModels] Failed to load PoseNet model:", error);
         }
       }
       this.initialized = true;
-      logger12.info("[VisionModels] Vision models initialized");
+      logger13.info("[VisionModels] Vision models initialized");
     } catch (error) {
-      logger12.error("[VisionModels] Initialization failed:", error);
+      logger13.error("[VisionModels] Initialization failed:", error);
       throw error;
     }
   }
@@ -3414,7 +3606,7 @@ class VisionModels {
   }
   async detectObjects(imageData, _width, _height, description) {
     if (!this.objectDetectionModel || !tf2) {
-      logger12.warn("[VisionModels] Object detection model not loaded");
+      logger13.warn("[VisionModels] Object detection model not loaded");
       return this.enhancedObjectDetection(description);
     }
     try {
@@ -3436,10 +3628,10 @@ class VisionModels {
           height: pred.bbox[3]
         }
       }));
-      logger12.debug(`[VisionModels] Detected ${objects.length} objects`);
+      logger13.debug(`[VisionModels] Detected ${objects.length} objects`);
       return objects;
     } catch (error) {
-      logger12.error("[VisionModels] Object detection failed:", error);
+      logger13.error("[VisionModels] Object detection failed:", error);
       return this.enhancedObjectDetection(description);
     }
   }
@@ -3449,8 +3641,14 @@ class VisionModels {
     }
     const objects = [];
     const objectPatterns = [
-      { pattern: /(\d+)?\s*(person|people|man|men|woman|women|child|children)/gi, type: "person" },
-      { pattern: /(\d+)?\s*(laptop|computer|monitor|screen|display)/gi, type: "laptop" },
+      {
+        pattern: /(\d+)?\s*(person|people|man|men|woman|women|child|children)/gi,
+        type: "person"
+      },
+      {
+        pattern: /(\d+)?\s*(laptop|computer|monitor|screen|display)/gi,
+        type: "laptop"
+      },
       { pattern: /(\d+)?\s*(phone|smartphone|mobile)/gi, type: "cell phone" },
       { pattern: /(\d+)?\s*(book|notebook|journal)/gi, type: "book" },
       { pattern: /(\d+)?\s*(cup|mug|glass|bottle)/gi, type: "cup" },
@@ -3500,7 +3698,7 @@ class VisionModels {
   }
   async detectPoses(imageData, width, height, description) {
     if (!this.poseDetector || !tf2) {
-      logger12.warn("[VisionModels] Pose detection model not loaded");
+      logger13.warn("[VisionModels] Pose detection model not loaded");
       return this.enhancedPoseDetection(description);
     }
     try {
@@ -3513,7 +3711,7 @@ class VisionModels {
       imageTensor.dispose();
       return this.convertPosesToPersonInfo(poses);
     } catch (error) {
-      logger12.error("[VisionModels] Pose detection failed:", error);
+      logger13.error("[VisionModels] Pose detection failed:", error);
       return this.enhancedPoseDetection(description);
     }
   }
@@ -3535,7 +3733,12 @@ class VisionModels {
       lying: ["lying", "laying", "reclined"]
     };
     const facingKeywords = {
-      camera: ["facing camera", "looking at camera", "facing forward", "front view"],
+      camera: [
+        "facing camera",
+        "looking at camera",
+        "facing forward",
+        "front view"
+      ],
       away: ["back to camera", "facing away", "back view"],
       left: ["facing left", "profile left", "left side"],
       right: ["facing right", "profile right", "right side"]
@@ -3697,7 +3900,7 @@ class VisionModels {
       this.poseDetector = null;
     }
     this.initialized = false;
-    logger12.info("[VisionModels] Models disposed");
+    logger13.info("[VisionModels] Models disposed");
   }
 }
 
@@ -3705,8 +3908,8 @@ class VisionModels {
 import * as path4 from "node:path";
 import { TextDecoder } from "node:util";
 import { Worker } from "node:worker_threads";
-import { logger as logger13 } from "@elizaos/core";
-var __dirname = "/Users/shawwalters/eliza-workspace/milady/plugins/plugin-vision/typescript/src";
+import { logger as logger14 } from "@elizaos/core";
+var __dirname = "/Users/shawwalters/eliza-workspace/milady/eliza/plugins/plugin-vision/src";
 
 class VisionWorkerManager {
   config;
@@ -3744,7 +3947,7 @@ class VisionWorkerManager {
     this.ocrResultsView = new DataView(this.ocrResultsBuffer);
   }
   async initialize() {
-    logger13.info("[VisionWorkerManager] Initializing worker threads...");
+    logger14.info("[VisionWorkerManager] Initializing worker threads...");
     try {
       await this.startScreenCaptureWorker();
       if (this.config.florence2Enabled) {
@@ -3753,9 +3956,9 @@ class VisionWorkerManager {
       if (this.config.ocrEnabled) {
         await this.startOCRWorker();
       }
-      logger13.info("[VisionWorkerManager] All workers initialized");
+      logger14.info("[VisionWorkerManager] All workers initialized");
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to initialize workers:", error);
+      logger14.error("[VisionWorkerManager] Failed to initialize workers:", error);
       throw error;
     }
   }
@@ -3780,18 +3983,18 @@ class VisionWorkerManager {
           lastUpdate: Date.now()
         });
       } else if (msg.type === "error") {
-        logger13.error("[ScreenCaptureWorker] Error:", msg.error);
+        logger14.error("[ScreenCaptureWorker] Error:", msg.error);
       } else if (msg.type === "log") {
         this.handleWorkerLog("ScreenCaptureWorker", msg);
       }
     });
     this.screenCaptureWorker.on("error", (error) => {
-      logger13.error("[ScreenCaptureWorker] Worker error:", error instanceof Error ? error.message : String(error));
+      logger14.error("[ScreenCaptureWorker] Worker error:", error instanceof Error ? error.message : String(error));
       setTimeout(() => this.restartScreenCaptureWorker(), 1000);
     });
     this.screenCaptureWorker.on("exit", (code) => {
       if (code !== 0) {
-        logger13.error(`[ScreenCaptureWorker] Worker stopped with exit code ${code}`);
+        logger14.error(`[ScreenCaptureWorker] Worker stopped with exit code ${code}`);
         setTimeout(() => this.restartScreenCaptureWorker(), 1000);
       }
     });
@@ -3830,18 +4033,18 @@ class VisionWorkerManager {
       } else if (msg.type === "tile_analyzed") {
         this.updateFlorence2Cache(msg);
       } else if (msg.type === "error") {
-        logger13.error("[Florence2Worker] Error:", msg.error);
+        logger14.error("[Florence2Worker] Error:", msg.error);
       } else if (msg.type === "log") {
         this.handleWorkerLog("Florence2Worker", msg);
       }
     });
     this.florence2Worker.on("error", (error) => {
-      logger13.error("[Florence2Worker] Worker error:", error instanceof Error ? error.message : String(error));
+      logger14.error("[Florence2Worker] Worker error:", error instanceof Error ? error.message : String(error));
       setTimeout(() => this.restartFlorence2Worker(), 1000);
     });
     this.florence2Worker.on("exit", (code) => {
       if (code !== 0) {
-        logger13.error(`[Florence2Worker] Worker stopped with exit code ${code}`);
+        logger14.error(`[Florence2Worker] Worker stopped with exit code ${code}`);
         setTimeout(() => this.restartFlorence2Worker(), 1000);
       }
     });
@@ -3869,18 +4072,18 @@ class VisionWorkerManager {
       } else if (msg.type === "ocr_complete") {
         this.updateOCRCache(msg);
       } else if (msg.type === "error") {
-        logger13.error("[OCRWorker] Error:", msg.error);
+        logger14.error("[OCRWorker] Error:", msg.error);
       } else if (msg.type === "log") {
         this.handleWorkerLog("OCRWorker", msg);
       }
     });
     this.ocrWorker.on("error", (error) => {
-      logger13.error("[OCRWorker] Worker error:", error instanceof Error ? error.message : String(error));
+      logger14.error("[OCRWorker] Worker error:", error instanceof Error ? error.message : String(error));
       setTimeout(() => this.restartOCRWorker(), 1000);
     });
     this.ocrWorker.on("exit", (code) => {
       if (code !== 0) {
-        logger13.error(`[OCRWorker] Worker stopped with exit code ${code}`);
+        logger14.error(`[OCRWorker] Worker stopped with exit code ${code}`);
         setTimeout(() => this.restartOCRWorker(), 1000);
       }
     });
@@ -3893,7 +4096,7 @@ class VisionWorkerManager {
         this.latestFlorence2Results.set(tileId, result);
       }
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to update Florence2 cache:", error);
+      logger14.error("[VisionWorkerManager] Failed to update Florence2 cache:", error);
     }
   }
   updateOCRCache(_msg) {
@@ -3903,7 +4106,7 @@ class VisionWorkerManager {
         this.latestOCRResult = result;
       }
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to update OCR cache:", error);
+      logger14.error("[VisionWorkerManager] Failed to update OCR cache:", error);
     }
   }
   readFlorence2Result(tileId) {
@@ -3929,7 +4132,7 @@ class VisionWorkerManager {
       const json = new TextDecoder().decode(bytes);
       return JSON.parse(json);
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to read Florence2 result:", error);
+      logger14.error("[VisionWorkerManager] Failed to read Florence2 result:", error);
       return null;
     }
   }
@@ -3951,7 +4154,7 @@ class VisionWorkerManager {
       const json = new TextDecoder().decode(bytes);
       return JSON.parse(json);
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to read OCR result:", error);
+      logger14.error("[VisionWorkerManager] Failed to read OCR result:", error);
       return null;
     }
   }
@@ -3974,7 +4177,7 @@ class VisionWorkerManager {
       };
       this.lastProcessedFrameId = frameId;
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to read screen capture:", error);
+      logger14.error("[VisionWorkerManager] Failed to read screen capture:", error);
     }
     return this.latestScreenCapture;
   }
@@ -4067,28 +4270,28 @@ class VisionWorkerManager {
     }
   }
   async stop() {
-    logger13.info("[VisionWorkerManager] Stopping all workers...");
+    logger14.info("[VisionWorkerManager] Stopping all workers...");
     const stopPromises = [];
     if (this.screenCaptureWorker) {
-      stopPromises.push(new Promise((resolve) => {
-        this.screenCaptureWorker?.once("exit", () => resolve());
+      stopPromises.push(new Promise((resolve2) => {
+        this.screenCaptureWorker?.once("exit", () => resolve2());
         this.screenCaptureWorker?.postMessage({ type: "stop" });
       }));
     }
     if (this.florence2Worker) {
-      stopPromises.push(new Promise((resolve) => {
-        this.florence2Worker?.once("exit", () => resolve());
+      stopPromises.push(new Promise((resolve2) => {
+        this.florence2Worker?.once("exit", () => resolve2());
         this.florence2Worker?.postMessage({ type: "stop" });
       }));
     }
     if (this.ocrWorker) {
-      stopPromises.push(new Promise((resolve) => {
-        this.ocrWorker?.once("exit", () => resolve());
+      stopPromises.push(new Promise((resolve2) => {
+        this.ocrWorker?.once("exit", () => resolve2());
         this.ocrWorker?.postMessage({ type: "stop" });
       }));
     }
     await Promise.all(stopPromises);
-    logger13.info("[VisionWorkerManager] All workers stopped");
+    logger14.info("[VisionWorkerManager] All workers stopped");
   }
   handleWorkerLog(workerName, msg) {
     const { level, message, args } = msg;
@@ -4096,27 +4299,27 @@ class VisionWorkerManager {
     const stringArgs = args.map((arg) => String(arg));
     switch (level) {
       case "info":
-        logger13.info(formattedMessage, ...stringArgs);
+        logger14.info(formattedMessage, ...stringArgs);
         break;
       case "warn":
-        logger13.warn(formattedMessage, ...stringArgs);
+        logger14.warn(formattedMessage, ...stringArgs);
         break;
       case "error":
-        logger13.error(formattedMessage, ...stringArgs);
+        logger14.error(formattedMessage, ...stringArgs);
         break;
       case "debug":
-        logger13.debug(formattedMessage, ...stringArgs);
+        logger14.debug(formattedMessage, ...stringArgs);
         break;
     }
   }
   async restartScreenCaptureWorker() {
     const attempts = this.restartAttempts.get("screenCapture") || 0;
     if (attempts >= this.MAX_RESTART_ATTEMPTS) {
-      logger13.error("[VisionWorkerManager] Max restart attempts reached for screen capture worker");
+      logger14.error("[VisionWorkerManager] Max restart attempts reached for screen capture worker");
       return;
     }
     this.restartAttempts.set("screenCapture", attempts + 1);
-    logger13.info(`[VisionWorkerManager] Restarting screen capture worker (attempt ${attempts + 1})`);
+    logger14.info(`[VisionWorkerManager] Restarting screen capture worker (attempt ${attempts + 1})`);
     try {
       if (this.screenCaptureWorker) {
         this.screenCaptureWorker.removeAllListeners();
@@ -4125,17 +4328,17 @@ class VisionWorkerManager {
       await this.startScreenCaptureWorker();
       this.restartAttempts.set("screenCapture", 0);
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to restart screen capture worker:", error);
+      logger14.error("[VisionWorkerManager] Failed to restart screen capture worker:", error);
     }
   }
   async restartFlorence2Worker() {
     const attempts = this.restartAttempts.get("florence2") || 0;
     if (attempts >= this.MAX_RESTART_ATTEMPTS) {
-      logger13.error("[VisionWorkerManager] Max restart attempts reached for Florence2 worker");
+      logger14.error("[VisionWorkerManager] Max restart attempts reached for Florence2 worker");
       return;
     }
     this.restartAttempts.set("florence2", attempts + 1);
-    logger13.info(`[VisionWorkerManager] Restarting Florence2 worker (attempt ${attempts + 1})`);
+    logger14.info(`[VisionWorkerManager] Restarting Florence2 worker (attempt ${attempts + 1})`);
     try {
       if (this.florence2Worker) {
         this.florence2Worker.removeAllListeners();
@@ -4144,17 +4347,17 @@ class VisionWorkerManager {
       await this.startFlorence2Worker();
       this.restartAttempts.set("florence2", 0);
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to restart Florence2 worker:", error);
+      logger14.error("[VisionWorkerManager] Failed to restart Florence2 worker:", error);
     }
   }
   async restartOCRWorker() {
     const attempts = this.restartAttempts.get("ocr") || 0;
     if (attempts >= this.MAX_RESTART_ATTEMPTS) {
-      logger13.error("[VisionWorkerManager] Max restart attempts reached for OCR worker");
+      logger14.error("[VisionWorkerManager] Max restart attempts reached for OCR worker");
       return;
     }
     this.restartAttempts.set("ocr", attempts + 1);
-    logger13.info(`[VisionWorkerManager] Restarting OCR worker (attempt ${attempts + 1})`);
+    logger14.info(`[VisionWorkerManager] Restarting OCR worker (attempt ${attempts + 1})`);
     try {
       if (this.ocrWorker) {
         this.ocrWorker.removeAllListeners();
@@ -4163,13 +4366,20 @@ class VisionWorkerManager {
       await this.startOCRWorker();
       this.restartAttempts.set("ocr", 0);
     } catch (error) {
-      logger13.error("[VisionWorkerManager] Failed to restart OCR worker:", error);
+      logger14.error("[VisionWorkerManager] Failed to restart OCR worker:", error);
     }
   }
 }
 
 // src/service.ts
 var execAsync3 = promisify3(exec3);
+var SCENE_DESCRIPTION_PROMPT = JSON.stringify({
+  task: "describe_visual_scene",
+  instructions: [
+    "Describe visible people, objects, UI, text, and notable scene changes.",
+    "Keep the answer concise and factual."
+  ]
+}, null, 2);
 
 class VisionService extends Service {
   static serviceType = VisionServiceType.VISION;
@@ -4223,7 +4433,7 @@ class VisionService extends Service {
     this.screenCapture = new ScreenCaptureService(this.visionConfig);
     this.florence2 = new Florence2Model;
     this.ocrService = new OCRService;
-    logger14.info("[VisionService] Constructed with config:", JSON.stringify(this.visionConfig));
+    logger15.info("[VisionService] Constructed with config:", JSON.stringify(this.visionConfig));
   }
   parseConfig(runtime) {
     const getSettingString = (key) => {
@@ -4278,14 +4488,14 @@ class VisionService extends Service {
             enableObjectDetection: this.visionConfig.enableObjectDetection || false,
             enablePoseDetection: this.visionConfig.enablePoseDetection || false
           });
-          logger14.info("[VisionService] Using TensorFlow.js models for advanced detection");
+          logger15.info("[VisionService] Using TensorFlow.js models for advanced detection");
         } catch (_tfError) {
-          logger14.warn("[VisionService] TensorFlow.js not available, falling back to enhanced heuristics");
+          logger15.warn("[VisionService] TensorFlow.js not available, falling back to enhanced heuristics");
           await this.visionModels.initialize({
             enableObjectDetection: this.visionConfig.enableObjectDetection || false,
             enablePoseDetection: this.visionConfig.enablePoseDetection || false
           });
-          logger14.info("[VisionService] Using enhanced heuristics for detection");
+          logger15.info("[VisionService] Using enhanced heuristics for detection");
         }
       }
       if (this.visionConfig.visionMode === "SCREEN" /* SCREEN */ || this.visionConfig.visionMode === "BOTH" /* BOTH */) {
@@ -4297,18 +4507,18 @@ class VisionService extends Service {
       await this.initializeAudioCapture();
       this.startProcessing();
     } catch (error) {
-      logger14.error("[VisionService] Failed to initialize:", error);
+      logger15.error("[VisionService] Failed to initialize:", error);
     }
   }
   async initializeScreenVision() {
     try {
-      logger14.info("[VisionService] Initializing screen vision...");
+      logger15.info("[VisionService] Initializing screen vision...");
       const useWorkers = this.visionConfig.targetScreenFPS && this.visionConfig.targetScreenFPS > 10;
       if (useWorkers) {
-        logger14.info("[VisionService] Initializing worker threads for high-FPS processing...");
+        logger15.info("[VisionService] Initializing worker threads for high-FPS processing...");
         this.workerManager = new VisionWorkerManager(this.visionConfig);
         await this.workerManager.initialize();
-        logger14.info("[VisionService] Worker threads initialized");
+        logger15.info("[VisionService] Worker threads initialized");
       } else {
         if (this.visionConfig.florence2Enabled) {
           await this.florence2.initialize();
@@ -4319,11 +4529,11 @@ class VisionService extends Service {
       }
       const screenInfo = await this.screenCapture.getScreenInfo();
       if (screenInfo) {
-        logger14.info(`[VisionService] Screen resolution: ${screenInfo.width}x${screenInfo.height}`);
+        logger15.info(`[VisionService] Screen resolution: ${screenInfo.width}x${screenInfo.height}`);
       }
-      logger14.info("[VisionService] Screen vision initialized");
+      logger15.info("[VisionService] Screen vision initialized");
     } catch (error) {
-      logger14.error("[VisionService] Failed to initialize screen vision:", error);
+      logger15.error("[VisionService] Failed to initialize screen vision:", error);
     }
   }
   async initializeCameraVision() {
@@ -4331,18 +4541,18 @@ class VisionService extends Service {
     if (!toolCheck.available) {
       const platform = process.platform;
       const toolName = platform === "darwin" ? "imagesnap" : platform === "linux" ? "fswebcam" : "ffmpeg";
-      logger14.warn(`[VisionService] Camera capture tool '${toolName}' not found. Install it to enable camera functionality.`);
-      logger14.warn("[VisionService] For macOS: brew install imagesnap");
-      logger14.warn("[VisionService] For Linux: sudo apt-get install fswebcam");
-      logger14.warn("[VisionService] For Windows: Install ffmpeg and add to PATH");
+      logger15.warn(`[VisionService] Camera capture tool '${toolName}' not found. Install it to enable camera functionality.`);
+      logger15.warn("[VisionService] For macOS: brew install imagesnap");
+      logger15.warn("[VisionService] For Linux: sudo apt-get install fswebcam");
+      logger15.warn("[VisionService] For Windows: Install ffmpeg and add to PATH");
       return;
     }
     const camera = await this.findCamera();
     if (camera) {
       this.camera = camera;
-      logger14.info(`[VisionService] Connected to camera: ${camera.name}`);
+      logger15.info(`[VisionService] Connected to camera: ${camera.name}`);
     } else {
-      logger14.warn("[VisionService] No suitable camera found");
+      logger15.warn("[VisionService] No suitable camera found");
     }
   }
   async initializeAudioCapture() {
@@ -4353,7 +4563,7 @@ class VisionService extends Service {
     const enableMicrophone = getSettingString("ENABLE_MICROPHONE") === "true";
     const useStreamingAudio = getSettingString("USE_STREAMING_AUDIO") === "true";
     if (!enableMicrophone) {
-      logger14.info("[VisionService] Microphone capture disabled");
+      logger15.info("[VisionService] Microphone capture disabled");
       return;
     }
     try {
@@ -4378,20 +4588,20 @@ class VisionService extends Service {
         };
         this.streamingAudioCapture = new StreamingAudioCaptureService(this.runtime, streamingConfig);
         this.streamingAudioCapture.on("speechStart", () => {
-          logger14.info("[VisionService] User started speaking");
+          logger15.info("[VisionService] User started speaking");
         });
         this.streamingAudioCapture.on("speechEnd", () => {
-          logger14.info("[VisionService] User stopped speaking");
+          logger15.info("[VisionService] User stopped speaking");
         });
         this.streamingAudioCapture.on("transcription", (data) => {
-          logger14.info(`[VisionService] Transcription (${data.isFinal ? "final" : "partial"}): ${data.text}`);
+          logger15.info(`[VisionService] Transcription (${data.isFinal ? "final" : "partial"}): ${data.text}`);
         });
         this.streamingAudioCapture.on("utteranceComplete", async (text) => {
-          logger14.info("[VisionService] Processing complete utterance:", text);
+          logger15.info("[VisionService] Processing complete utterance:", text);
           await this.storeAudioTranscription(text);
         });
         await this.streamingAudioCapture.initialize();
-        logger14.info("[VisionService] Streaming audio capture initialized with VAD");
+        logger15.info("[VisionService] Streaming audio capture initialized with VAD");
       } else {
         const getSettingNumber = (key, defaultValue) => {
           const value = this.runtime.getSetting(key);
@@ -4409,10 +4619,10 @@ class VisionService extends Service {
         };
         this.audioCapture = new AudioCaptureService(this.runtime, audioConfig);
         await this.audioCapture.initialize();
-        logger14.info("[VisionService] Batch audio capture initialized");
+        logger15.info("[VisionService] Batch audio capture initialized");
       }
     } catch (error) {
-      logger14.error("[VisionService] Failed to initialize audio capture:", error);
+      logger15.error("[VisionService] Failed to initialize audio capture:", error);
     }
   }
   async storeAudioTranscription(text) {
@@ -4420,9 +4630,9 @@ class VisionService extends Service {
       if (this.lastSceneDescription) {
         this.lastSceneDescription.audioTranscription = text;
       }
-      logger14.debug("[VisionService] Stored audio transcription in scene context");
+      logger15.debug("[VisionService] Stored audio transcription in scene context");
     } catch (error) {
-      logger14.error("[VisionService] Failed to store audio transcription:", error);
+      logger15.error("[VisionService] Failed to store audio transcription:", error);
     }
   }
   startProcessing() {
@@ -4443,12 +4653,12 @@ class VisionService extends Service {
         try {
           await this.captureAndProcessFrame();
         } catch (error) {
-          logger14.error("[VisionService] Frame processing error:", error);
+          logger15.error("[VisionService] Frame processing error:", error);
         }
         this.isProcessing = false;
       }
     }, this.visionConfig.updateInterval || 100);
-    logger14.debug("[VisionService] Started frame processing loop");
+    logger15.debug("[VisionService] Started frame processing loop");
   }
   async captureAndProcessFrame() {
     if (!this.camera) {
@@ -4457,19 +4667,19 @@ class VisionService extends Service {
     try {
       const frameData = await this.camera.capture();
       if (!frameData || frameData.length === 0) {
-        logger14.debug("[VisionService] Camera returned empty frame, skipping");
+        logger15.debug("[VisionService] Camera returned empty frame, skipping");
         return;
       }
       const frame = await this.processFrameData(frameData);
       if (!frame || frame.width === 0 || frame.height === 0) {
-        logger14.warn("[VisionService] Invalid frame dimensions, skipping");
+        logger15.warn("[VisionService] Invalid frame dimensions, skipping");
         return;
       }
       const changePercentage = this.lastFrame ? await this.calculatePixelChange(this.lastFrame, frame) : 100;
       await this.updateSceneDescription(frame, changePercentage);
       this.lastFrame = frame;
     } catch (error) {
-      logger14.error("[VisionService] Error capturing frame:", error);
+      logger15.error("[VisionService] Error capturing frame:", error);
     }
   }
   async processFrameData(data) {
@@ -4516,7 +4726,8 @@ class VisionService extends Service {
   async updateSceneDescription(frame, changePercentage) {
     try {
       const currentTime = Date.now();
-      const jpegBuffer = await sharp4(frame.data, {
+      const testImage = getTestImage();
+      const jpegBuffer = testImage ? await sharp4(testImage).jpeg().toBuffer() : await sharp4(frame.data, {
         raw: {
           width: frame.width,
           height: frame.height,
@@ -4534,7 +4745,7 @@ class VisionService extends Service {
         description = await this.describeSceneWithVLM(imageUrl);
         this.lastVlmUpdateTime = currentTime;
         this.lastTfDescription = description;
-        logger14.debug(`[VisionService] VLM updated: ${timeSinceVlmUpdate}ms since last update, ${changePercentage.toFixed(1)}% change`);
+        logger15.debug(`[VisionService] VLM updated: ${timeSinceVlmUpdate}ms since last update, ${changePercentage.toFixed(1)}% change`);
       }
       const timeSinceTfUpdate = currentTime - this.lastTfUpdateTime;
       const tfUpdateInterval = this.visionConfig.tfUpdateInterval ?? 1000;
@@ -4544,18 +4755,18 @@ class VisionService extends Service {
       let people = [];
       if (shouldUpdateTf && (this.visionConfig.enableObjectDetection || this.visionConfig.enablePoseDetection)) {
         this.lastTfUpdateTime = currentTime;
-        logger14.debug(`[VisionService] TF updating: ${timeSinceTfUpdate}ms since last update, ${changePercentage.toFixed(1)}% change`);
+        logger15.debug(`[VisionService] TF updating: ${timeSinceTfUpdate}ms since last update, ${changePercentage.toFixed(1)}% change`);
         if (this.visionConfig.enableObjectDetection) {
           if (this.visionModels.hasObjectDetection()) {
             detectedObjects = await this.visionModels.detectObjects(frame.data, frame.width, frame.height);
-            logger14.debug(`[VisionService] VisionModels detected ${detectedObjects.length} objects`);
+            logger15.debug(`[VisionService] VisionModels detected ${detectedObjects.length} objects`);
           }
         }
         if (this.visionConfig.enablePoseDetection) {
           if (this.visionModels.hasPoseDetection()) {
             const poses = await this.visionModels.detectPoses(frame.data, frame.width, frame.height);
             people = poses;
-            logger14.debug(`[VisionService] VisionModels detected ${people.length} people with poses`);
+            logger15.debug(`[VisionService] VisionModels detected ${people.length} people with poses`);
           }
         }
         if (people.length === 0 && detectedObjects.length > 0) {
@@ -4583,8 +4794,8 @@ class VisionService extends Service {
       const enableFaceRecognition = getSettingString("ENABLE_FACE_RECOGNITION") === "true";
       if (enableFaceRecognition && people.length > 0 && frame.width > 0 && frame.height > 0) {
         try {
-          if (!frame.data || frame.data.length === 0) {
-            logger14.warn("[VisionService] Invalid frame data for face recognition");
+          if (frame.data.length === 0) {
+            logger15.warn("[VisionService] Invalid frame data for face recognition");
             return;
           }
           const faces = await this.faceRecognition.detectFaces(frame.data, frame.width, frame.height);
@@ -4602,7 +4813,7 @@ class VisionService extends Service {
                 let profileId;
                 if (match) {
                   profileId = match.profileId;
-                  logger14.debug(`[VisionService] Recognized face: ${profileId} (distance: ${match.distance})`);
+                  logger15.debug(`[VisionService] Recognized face: ${profileId} (distance: ${match.distance})`);
                 } else {
                   profileId = await this.faceRecognition.addOrUpdateFace(face.descriptor, {
                     attributes: {
@@ -4611,7 +4822,7 @@ class VisionService extends Service {
                       emotion: face.expressions ? this.getDominantExpression(face.expressions) : undefined
                     }
                   });
-                  logger14.info(`[VisionService] New face registered: ${profileId}`);
+                  logger15.info(`[VisionService] New face registered: ${profileId}`);
                 }
                 faceProfiles.set(person.id, profileId);
                 break;
@@ -4619,7 +4830,7 @@ class VisionService extends Service {
             }
           }
         } catch (faceError) {
-          logger14.error("[VisionService] Face recognition error:", faceError);
+          logger15.error("[VisionService] Face recognition error:", faceError);
         }
       }
       const _trackedEntities = await this.entityTracker.updateEntities(detectedObjects, people, faceProfiles, this.runtime);
@@ -4632,51 +4843,75 @@ class VisionService extends Service {
         changePercentage
       };
       if (shouldUpdateVlm || shouldUpdateTf) {
-        logger14.info("[VisionService] Scene Analysis Complete:");
-        logger14.info(`  VLM Description: ${description.substring(0, 100)}...`);
-        logger14.info(`  Change: ${changePercentage.toFixed(1)}%`);
-        logger14.info(`  Updates: ${shouldUpdateVlm ? "VLM" : ""}${shouldUpdateVlm && shouldUpdateTf ? " + " : ""}${shouldUpdateTf ? "TF" : ""}`);
-        logger14.info(`  Detection Mode: ${this.visionConfig.enableObjectDetection ? "Advanced CV" : "Motion-based"}`);
+        logger15.info("[VisionService] Scene Analysis Complete:");
+        logger15.info(`  VLM Description: ${description.substring(0, 100)}...`);
+        logger15.info(`  Change: ${changePercentage.toFixed(1)}%`);
+        logger15.info(`  Updates: ${shouldUpdateVlm ? "VLM" : ""}${shouldUpdateVlm && shouldUpdateTf ? " + " : ""}${shouldUpdateTf ? "TF" : ""}`);
+        logger15.info(`  Detection Mode: ${this.visionConfig.enableObjectDetection ? "Advanced CV" : "Motion-based"}`);
         if (detectedObjects.length > 0) {
-          logger14.info(`  Objects: ${detectedObjects.length} detected`);
+          logger15.info(`  Objects: ${detectedObjects.length} detected`);
           const objectSummary = detectedObjects.reduce((acc, obj) => {
             acc[obj.type] = (acc[obj.type] || 0) + 1;
             return acc;
           }, {});
           for (const [type, count] of Object.entries(objectSummary)) {
-            logger14.info(`    - ${count} ${type}(s)`);
+            logger15.info(`    - ${count} ${type}(s)`);
           }
         }
         if (people.length > 0) {
-          logger14.info(`  People: ${people.length} detected`);
+          logger15.info(`  People: ${people.length} detected`);
           for (const person of people) {
-            logger14.info(`    - Person: ${person.pose} pose, facing ${person.facing}, confidence: ${person.confidence.toFixed(2)}`);
+            logger15.info(`    - Person: ${person.pose} pose, facing ${person.facing}, confidence: ${person.confidence.toFixed(2)}`);
           }
         }
       }
     } catch (error) {
-      logger14.error("[VisionService] Failed to update scene description:", error);
+      logger15.error("[VisionService] Failed to update scene description:", error);
     }
   }
   async describeSceneWithVLM(imageUrl) {
+    return withStandaloneTrajectory3(this.runtime, {
+      source: "plugin-vision:scene-description",
+      metadata: { modelType: ModelType3.IMAGE_DESCRIPTION }
+    }, () => this.describeSceneWithVLMInTrajectory(imageUrl));
+  }
+  async describeSceneWithVLMInTrajectory(imageUrl) {
     try {
       if (imageUrl.startsWith("data:image/")) {
         const base64Data = imageUrl.split(",")[1];
         const imageBuffer = Buffer.from(base64Data, "base64");
         if (this.florence2.isInitialized()) {
           try {
-            const result = await this.florence2.analyzeImage(imageBuffer);
+            const result = await recordLlmCall(this.runtime, {
+              model: "florence2-local",
+              systemPrompt: "",
+              userPrompt: JSON.stringify({
+                task: "describe_visual_scene",
+                image: {
+                  source: "camera_frame",
+                  mimeType: "image/jpeg",
+                  bytes: imageBuffer.byteLength
+                }
+              }, null, 2),
+              temperature: 0,
+              maxTokens: 0,
+              purpose: "background",
+              actionType: "florence2.analyzeImage"
+            }, () => this.florence2.analyzeImage(imageBuffer));
             if (result.caption) {
-              logger14.debug("[VisionService] Florence-2 description:", result.caption);
+              logger15.debug("[VisionService] Florence-2 description:", result.caption);
               return result.caption;
             }
           } catch (florenceError) {
-            logger14.warn("[VisionService] Florence-2 analysis failed, falling back:", florenceError);
+            logger15.warn("[VisionService] Florence-2 analysis failed, falling back:", florenceError);
           }
         }
       }
       try {
-        const result = await this.runtime.useModel(ModelType3.IMAGE_DESCRIPTION, imageUrl);
+        const result = await this.runtime.useModel(ModelType3.IMAGE_DESCRIPTION, {
+          imageUrl,
+          prompt: SCENE_DESCRIPTION_PROMPT
+        });
         if (result && typeof result === "object" && "description" in result) {
           const description = result.description;
           if (!description.includes("I'm unable to analyze images") && !description.includes("I can't analyze images")) {
@@ -4689,7 +4924,7 @@ class VisionService extends Service {
           }
         }
       } catch (modelError) {
-        logger14.warn("[VisionService] Runtime IMAGE_DESCRIPTION model failed:", modelError);
+        logger15.warn("[VisionService] Runtime IMAGE_DESCRIPTION model failed:", modelError);
       }
       if (this.lastSceneDescription) {
         const { objects, people } = this.lastSceneDescription;
@@ -4715,7 +4950,7 @@ class VisionService extends Service {
       }
       return "Visual scene captured";
     } catch (error) {
-      logger14.error("[VisionService] VLM description failed:", error);
+      logger15.error("[VisionService] VLM description failed:", error);
       return "Unable to describe scene";
     }
   }
@@ -4879,12 +5114,12 @@ class VisionService extends Service {
         try {
           await this.captureAndProcessScreen();
         } catch (error) {
-          logger14.error("[VisionService] Screen processing error:", error);
+          logger15.error("[VisionService] Screen processing error:", error);
         }
         this.isProcessingScreen = false;
       }
     }, this.visionConfig.screenCaptureInterval || 2000);
-    logger14.debug("[VisionService] Started screen processing loop");
+    logger15.debug("[VisionService] Started screen processing loop");
   }
   async captureAndProcessScreen() {
     try {
@@ -4897,7 +5132,7 @@ class VisionService extends Service {
       }
       await this.updateEnhancedSceneDescription();
     } catch (error) {
-      logger14.error("[VisionService] Error capturing screen:", error);
+      logger15.error("[VisionService] Error capturing screen:", error);
     }
   }
   async analyzeTile(tile) {
@@ -4922,7 +5157,7 @@ class VisionService extends Service {
         }));
       }
     } catch (error) {
-      logger14.error("[VisionService] Error analyzing tile:", error);
+      logger15.error("[VisionService] Error analyzing tile:", error);
     }
     return analysis;
   }
@@ -4984,11 +5219,11 @@ class VisionService extends Service {
     return this.visionConfig.visionMode || "CAMERA" /* CAMERA */;
   }
   async setVisionMode(mode) {
-    logger14.info(`[VisionService] Changing vision mode from ${this.visionConfig.visionMode} to ${mode}`);
+    logger15.info(`[VisionService] Changing vision mode from ${this.visionConfig.visionMode} to ${mode}`);
     this.stopProcessing();
     this.visionConfig.visionMode = mode;
     if (mode === "OFF" /* OFF */) {
-      logger14.info("[VisionService] Vision disabled");
+      logger15.info("[VisionService] Vision disabled");
       return;
     }
     if ((mode === "CAMERA" /* CAMERA */ || mode === "BOTH" /* BOTH */) && !this.camera) {
@@ -5063,7 +5298,7 @@ class VisionService extends Service {
     return this.faceRecognition;
   }
   async stop() {
-    logger14.info("[VisionService] Stopping vision service...");
+    logger15.info("[VisionService] Stopping vision service...");
     this.stopProcessing();
     if (this.audioCapture) {
       await this.audioCapture.stop();
@@ -5089,13 +5324,13 @@ class VisionService extends Service {
     this.isProcessingScreen = false;
     await this.florence2.dispose();
     await this.ocrService.dispose();
-    logger14.info("[VisionService] Stopped.");
+    logger15.info("[VisionService] Stopped.");
   }
   async findCamera() {
     try {
       const cameras = await this.listCameras();
       if (cameras.length === 0) {
-        logger14.warn("[VisionService] No cameras detected");
+        logger15.warn("[VisionService] No cameras detected");
         return null;
       }
       if (this.visionConfig.cameraName) {
@@ -5104,11 +5339,11 @@ class VisionService extends Service {
         if (matchedCamera) {
           return this.createCameraDevice(matchedCamera);
         }
-        logger14.warn(`[VisionService] Camera "${this.visionConfig.cameraName}" not found, using default`);
+        logger15.warn(`[VisionService] Camera "${this.visionConfig.cameraName}" not found, using default`);
       }
       return this.createCameraDevice(cameras[0]);
     } catch (error) {
-      logger14.error("[VisionService] Error finding camera:", error);
+      logger15.error("[VisionService] Error finding camera:", error);
       return null;
     }
   }
@@ -5166,7 +5401,7 @@ class VisionService extends Service {
       }
       return [];
     } catch (error) {
-      logger14.error("[VisionService] Error listing cameras:", error);
+      logger15.error("[VisionService] Error listing cameras:", error);
       return [];
     }
   }
@@ -5223,13 +5458,13 @@ class VisionService extends Service {
   }
   async captureImage() {
     if (!this.camera) {
-      logger14.warn("[VisionService] No camera available for capture");
+      logger15.warn("[VisionService] No camera available for capture");
       return null;
     }
     try {
       return await this.camera.capture();
     } catch (error) {
-      logger14.error("[VisionService] Failed to capture image:", error);
+      logger15.error("[VisionService] Failed to capture image:", error);
       return null;
     }
   }
@@ -5250,7 +5485,7 @@ class ScreenVisionE2ETestSuite {
           throw new Error("Vision service not available");
         }
         await visionService.setVisionMode("SCREEN" /* SCREEN */);
-        await new Promise((resolve) => setTimeout(resolve, 2000));
+        await new Promise((resolve2) => setTimeout(resolve2, 2000));
         const mode = visionService.getVisionMode();
         if (mode !== "SCREEN" /* SCREEN */) {
           throw new Error(`Expected vision mode SCREEN but got ${mode}`);
@@ -5273,7 +5508,7 @@ class ScreenVisionE2ETestSuite {
           throw new Error("Vision service not available");
         }
         await visionService.setVisionMode("SCREEN" /* SCREEN */);
-        await new Promise((resolve) => setTimeout(resolve, 3000));
+        await new Promise((resolve2) => setTimeout(resolve2, 3000));
         const screenCapture = await visionService.getScreenCapture();
         if (!screenCapture) {
           console.warn("⚠️  No screen capture available - screen capture may not be supported in this environment");
@@ -5303,7 +5538,7 @@ class ScreenVisionE2ETestSuite {
           throw new Error("Vision service not available");
         }
         await visionService.setVisionMode("SCREEN" /* SCREEN */);
-        await new Promise((resolve) => setTimeout(resolve, 5000));
+        await new Promise((resolve2) => setTimeout(resolve2, 5000));
         const enhancedScene = await visionService.getEnhancedSceneDescription();
         if (!enhancedScene || !enhancedScene.screenAnalysis) {
           console.warn("⚠️  No enhanced scene analysis available yet");
@@ -5342,18 +5577,23 @@ class ScreenVisionE2ETestSuite {
         if (!visionService) {
           throw new Error("Vision service not available");
         }
-        const modes = ["CAMERA" /* CAMERA */, "SCREEN" /* SCREEN */, "BOTH" /* BOTH */, "OFF" /* OFF */];
+        const modes = [
+          "CAMERA" /* CAMERA */,
+          "SCREEN" /* SCREEN */,
+          "BOTH" /* BOTH */,
+          "OFF" /* OFF */
+        ];
         for (const mode of modes) {
           console.log(`  Switching to ${mode} mode...`);
           await visionService.setVisionMode(mode);
-          await new Promise((resolve) => setTimeout(resolve, 1000));
+          await new Promise((resolve2) => setTimeout(resolve2, 1000));
           const currentMode = visionService.getVisionMode();
           if (currentMode !== mode) {
             throw new Error(`Failed to switch to ${mode} mode, current mode is ${currentMode}`);
           }
           console.log(`  ✓ Successfully switched to ${mode} mode`);
         }
-        console.log("  Testing SET_VISION_MODE action...");
+        console.log("  Testing VISION action with op=set_mode...");
         const message = {
           id: createUniqueUuid3(runtime, "test-msg"),
           entityId: runtime.agentId,
@@ -5363,13 +5603,13 @@ class ScreenVisionE2ETestSuite {
           createdAt: Date.now()
         };
         let callbackCalled = false;
-        await setVisionModeAction.handler(runtime, message, { values: {}, data: {}, text: "" }, {}, async (response) => {
+        await visionAction.handler(runtime, message, { values: {}, data: {}, text: "" }, { parameters: { op: "set_mode" } }, async (response) => {
           callbackCalled = true;
           console.log(`  Action response: ${response.text}`);
           return [];
         });
         if (!callbackCalled) {
-          throw new Error("SET_VISION_MODE action did not call callback");
+          throw new Error("VISION set_mode op did not call callback");
         }
         const finalMode = visionService.getVisionMode();
         if (finalMode !== "BOTH" /* BOTH */) {
@@ -5387,7 +5627,7 @@ class ScreenVisionE2ETestSuite {
           throw new Error("Vision service not available");
         }
         await visionService.setVisionMode("BOTH" /* BOTH */);
-        await new Promise((resolve) => setTimeout(resolve, 5000));
+        await new Promise((resolve2) => setTimeout(resolve2, 5000));
         const enhancedScene = await visionService.getEnhancedSceneDescription();
         const hasCamera = visionService.getCameraInfo() !== null;
         const hasScreen = await visionService.getScreenCapture() !== null;
@@ -5428,19 +5668,22 @@ class ScreenVisionE2ETestSuite {
         if (!visionService) {
           throw new Error("Vision service not available");
         }
-        const testableService = visionService;
-        const originalConfig = testableService.visionConfig;
-        testableService.visionConfig.screenRegion = {
-          x: -100,
-          y: -100,
-          width: 50000,
-          height: 50000
+        const originalConfig = Reflect.get(visionService, "visionConfig");
+        const invalidConfig = {
+          ...originalConfig,
+          screenRegion: {
+            x: -100,
+            y: -100,
+            width: 50000,
+            height: 50000
+          }
         };
+        Reflect.set(visionService, "visionConfig", invalidConfig);
         await visionService.setVisionMode("SCREEN" /* SCREEN */);
-        await new Promise((resolve) => setTimeout(resolve, 2000));
+        await new Promise((resolve2) => setTimeout(resolve2, 2000));
         const isActive = visionService.isActive();
         console.log(`  Service active after invalid config: ${isActive}`);
-        testableService.visionConfig = originalConfig;
+        Reflect.set(visionService, "visionConfig", originalConfig);
         console.log("✓ Error handling works correctly");
       }
     }
@@ -5489,13 +5732,13 @@ class VisionBasicE2ETestSuite {
         let callbackResponse = null;
         const state = { values: {}, data: {}, text: "" };
         const visionService = runtime.getService("VISION");
-        const isValid = await describeSceneAction.validate(runtime, message, state);
+        const isValid = await visionAction.validate(runtime, message, state);
         if (!visionService || !visionService.isActive()) {
           if (isValid) {
             throw new Error("Action validation should return false when vision service is not active");
           }
           console.log("  Action validation correctly returned false (vision not active)");
-          await describeSceneAction.handler(runtime, message, state, {}, async (response) => {
+          await visionAction.handler(runtime, message, state, { parameters: { op: "describe" } }, async (response) => {
             callbackCalled = true;
             callbackResponse = response;
             return [];
@@ -5513,10 +5756,10 @@ class VisionBasicE2ETestSuite {
           }
         } else {
           if (!isValid) {
-            throw new Error("describeSceneAction validation failed despite active vision");
+            throw new Error("visionAction validation failed despite active vision");
           }
           console.log("  Action validation: passed");
-          await describeSceneAction.handler(runtime, message, state, {}, async (response) => {
+          await visionAction.handler(runtime, message, state, { parameters: { op: "describe" } }, async (response) => {
             callbackCalled = true;
             callbackResponse = response;
             return [];
@@ -5533,8 +5776,8 @@ class VisionBasicE2ETestSuite {
             console.log(`  Thought: ${callbackResponse.thought}`);
           }
         }
-        if (!callbackResponse.actions || !callbackResponse.actions.includes("DESCRIBE_SCENE")) {
-          throw new Error("Response does not include DESCRIBE_SCENE action");
+        if (!callbackResponse.actions || !callbackResponse.actions.includes("VISION")) {
+          throw new Error("Response does not include VISION action");
         }
       }
     },
@@ -5555,13 +5798,13 @@ class VisionBasicE2ETestSuite {
         let callbackResponse = null;
         const state = { values: {}, data: {}, text: "" };
         const visionService = runtime.getService("VISION");
-        const isValid = await captureImageAction.validate(runtime, message, state);
+        const isValid = await visionAction.validate(runtime, message, state);
         if (!visionService || !visionService.isActive()) {
           if (isValid) {
             throw new Error("Action validation should return false when vision service is not active");
           }
           console.log("  Action validation correctly returned false (vision not active)");
-          await captureImageAction.handler(runtime, message, state, {}, async (response) => {
+          await visionAction.handler(runtime, message, state, { parameters: { op: "capture" } }, async (response) => {
             callbackCalled = true;
             callbackResponse = response;
             return [];
@@ -5579,10 +5822,10 @@ class VisionBasicE2ETestSuite {
           }
         } else {
           if (!isValid) {
-            throw new Error("captureImageAction validation failed despite active vision");
+            throw new Error("visionAction validation failed despite active vision");
           }
           console.log("  Action validation: passed");
-          await captureImageAction.handler(runtime, message, state, {}, async (response) => {
+          await visionAction.handler(runtime, message, state, { parameters: { op: "capture" } }, async (response) => {
             callbackCalled = true;
             callbackResponse = response;
             return [];
@@ -5604,8 +5847,8 @@ class VisionBasicE2ETestSuite {
           }
           console.log(`  ✓ Image attachment valid: ${attachment.title}`);
         }
-        if (!callbackResponse.actions || !callbackResponse.actions.includes("CAPTURE_IMAGE")) {
-          throw new Error("Response does not include CAPTURE_IMAGE action");
+        if (!callbackResponse.actions || !callbackResponse.actions.includes("VISION")) {
+          throw new Error("Response does not include VISION action");
         }
       }
     },
@@ -5652,7 +5895,7 @@ class VisionBasicE2ETestSuite {
         }
         const initialScene = await visionService.getSceneDescription();
         console.log(`  Initial scene: ${initialScene ? "Available" : "Pending..."}`);
-        await new Promise((resolve) => setTimeout(resolve, 2000));
+        await new Promise((resolve2) => setTimeout(resolve2, 2000));
         const updatedScene = await visionService.getSceneDescription();
         if (!updatedScene) {
           throw new Error("No scene description available after 2 seconds");
@@ -5679,7 +5922,7 @@ class VisionBasicE2ETestSuite {
           return;
         }
         console.log("  Waiting for scene analysis...");
-        await new Promise((resolve) => setTimeout(resolve, 3000));
+        await new Promise((resolve2) => setTimeout(resolve2, 3000));
         const scene = await visionService.getSceneDescription();
         if (!scene) {
           throw new Error("No scene description available after 3 seconds");
@@ -5869,7 +6112,7 @@ class VisionCaptureLogTestSuite {
           const captureDuration = captureEndTime - captureStartTime;
           const waitTime = Math.max(0, captureInterval - captureDuration);
           if (waitTime > 0) {
-            await new Promise((resolve) => setTimeout(resolve, waitTime));
+            await new Promise((resolve2) => setTimeout(resolve2, waitTime));
           }
         }
         captureData.endTime = new Date().toISOString();
@@ -5942,7 +6185,7 @@ ${captureData.captures.filter((c) => c.scene?.description).slice(0, 5).map((c, _
 }
 var vision_capture_log_default = new VisionCaptureLogTestSuite;
 // src/tests/e2e/vision-runtime.ts
-import { logger as logger15 } from "@elizaos/core";
+import { logger as logger16 } from "@elizaos/core";
 class VisionRuntimeTestSuite {
   name = "vision-runtime-tests";
   description = "Real runtime tests for vision plugin functionality";
@@ -5950,7 +6193,7 @@ class VisionRuntimeTestSuite {
     {
       name: "Vision service initialization",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing vision service initialization...");
+        logger16.info("[Test] Testing vision service initialization...");
         const visionService = runtime.getService(VisionServiceType.VISION);
         if (!visionService) {
           throw new Error("Vision service not found in runtime");
@@ -5959,24 +6202,24 @@ class VisionRuntimeTestSuite {
           throw new Error("Vision service missing isActive method");
         }
         const isActive = visionService.isActive();
-        logger15.info(`[Test] Vision service active: ${isActive}`);
+        logger16.info(`[Test] Vision service active: ${isActive}`);
         if (!isActive && runtime.getSetting("VISION_MODE") !== "OFF" /* OFF */) {
           throw new Error("Vision service should be active but is not");
         }
-        logger15.info("[Test] ✅ Vision service initialization test passed");
+        logger16.info("[Test] ✅ Vision service initialization test passed");
       }
     },
     {
       name: "Scene description functionality",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing scene description...");
+        logger16.info("[Test] Testing scene description...");
         const visionService = runtime.getService(VisionServiceType.VISION);
         if (!visionService) {
           throw new Error("Vision service not found");
         }
         const scene = await visionService.getSceneDescription();
         if (!scene) {
-          logger15.warn("[Test] No scene description available (camera might not be connected)");
+          logger16.warn("[Test] No scene description available (camera might not be connected)");
           return;
         }
         if (typeof scene.timestamp !== "number") {
@@ -5991,21 +6234,21 @@ class VisionRuntimeTestSuite {
         if (!Array.isArray(scene.people)) {
           throw new Error("Scene description missing people array");
         }
-        logger15.info(`[Test] Scene: ${scene.description.substring(0, 100)}...`);
-        logger15.info(`[Test] Objects: ${scene.objects.length}, People: ${scene.people.length}`);
-        logger15.info("[Test] ✅ Scene description test passed");
+        logger16.info(`[Test] Scene: ${scene.description.substring(0, 100)}...`);
+        logger16.info(`[Test] Objects: ${scene.objects.length}, People: ${scene.people.length}`);
+        logger16.info("[Test] ✅ Scene description test passed");
       }
     },
     {
       name: "Vision mode switching",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing vision mode switching...");
+        logger16.info("[Test] Testing vision mode switching...");
         const visionService = runtime.getService(VisionServiceType.VISION);
         if (!visionService) {
           throw new Error("Vision service not found");
         }
         const originalMode = visionService.getVisionMode();
-        logger15.info(`[Test] Original mode: ${originalMode}`);
+        logger16.info(`[Test] Original mode: ${originalMode}`);
         const testModes = [
           "CAMERA" /* CAMERA */,
           "SCREEN" /* SCREEN */,
@@ -6013,7 +6256,7 @@ class VisionRuntimeTestSuite {
           "OFF" /* OFF */
         ];
         for (const mode of testModes) {
-          logger15.info(`[Test] Switching to mode: ${mode}`);
+          logger16.info(`[Test] Switching to mode: ${mode}`);
           await visionService.setVisionMode(mode);
           const currentMode = visionService.getVisionMode();
           if (currentMode !== mode) {
@@ -6021,16 +6264,16 @@ class VisionRuntimeTestSuite {
           }
         }
         await visionService.setVisionMode(originalMode);
-        logger15.info("[Test] ✅ Vision mode switching test passed");
+        logger16.info("[Test] ✅ Vision mode switching test passed");
       }
     },
     {
-      name: "DESCRIBE_SCENE action execution",
+      name: "VISION action describe op execution",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing DESCRIBE_SCENE action...");
-        const action = runtime.actions.find((a) => a.name === "DESCRIBE_SCENE");
+        logger16.info("[Test] Testing VISION action with op=describe...");
+        const action = runtime.actions.find((a) => a.name === "VISION");
         if (!action) {
-          throw new Error("DESCRIBE_SCENE action not found");
+          throw new Error("VISION action not found");
         }
         const message = {
           id: `test-msg-${Date.now()}`,
@@ -6044,27 +6287,27 @@ class VisionRuntimeTestSuite {
         };
         const isValid = await action.validate(runtime, message);
         if (!isValid) {
-          throw new Error("DESCRIBE_SCENE action validation failed");
+          throw new Error("VISION action validation failed");
         }
         let responseReceived = false;
         const callback = async (response) => {
           if (response.text && response.text.length > 0) {
             responseReceived = true;
-            logger15.info(`[Test] Action response: ${response.text.substring(0, 100)}...`);
+            logger16.info(`[Test] Action response: ${response.text.substring(0, 100)}...`);
           }
           return [];
         };
-        await action.handler(runtime, message, { values: {}, data: {}, text: "" }, {}, callback);
+        await action.handler(runtime, message, { values: {}, data: {}, text: "" }, { parameters: { op: "describe" } }, callback);
         if (!responseReceived) {
-          throw new Error("DESCRIBE_SCENE action did not produce a response");
+          throw new Error("VISION action with op=describe did not produce a response");
         }
-        logger15.info("[Test] ✅ DESCRIBE_SCENE action test passed");
+        logger16.info("[Test] ✅ VISION action describe op test passed");
       }
     },
     {
       name: "Vision provider integration",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing vision provider...");
+        logger16.info("[Test] Testing vision provider...");
         const provider = runtime.providers.find((p) => p.name === "visionProvider");
         if (!provider) {
           throw new Error("Vision provider not found");
@@ -6086,47 +6329,47 @@ class VisionRuntimeTestSuite {
           throw new Error("Vision provider returned invalid result");
         }
         if (result.text?.includes("I can see")) {
-          logger15.info(`[Test] Provider text: ${result.text.substring(0, 100)}...`);
+          logger16.info(`[Test] Provider text: ${result.text.substring(0, 100)}...`);
         }
-        logger15.info("[Test] ✅ Vision provider test passed");
+        logger16.info("[Test] ✅ Vision provider test passed");
       }
     },
     {
       name: "Florence-2 model initialization",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing Florence-2 model...");
+        logger16.info("[Test] Testing Florence-2 model...");
         const visionService = runtime.getService(VisionServiceType.VISION);
         if (!visionService) {
           throw new Error("Vision service not found");
         }
         const florence2Enabled = runtime.getSetting("FLORENCE2_ENABLED") === "true" || runtime.getSetting("VISION_FLORENCE2_ENABLED") === "true";
         if (!florence2Enabled) {
-          logger15.info("[Test] Florence-2 is disabled, skipping test");
+          logger16.info("[Test] Florence-2 is disabled, skipping test");
           return;
         }
         const mode = visionService.getVisionMode();
         if (mode === "SCREEN" /* SCREEN */ || mode === "BOTH" /* BOTH */) {
           const screenCapture = await visionService.getScreenCapture();
           if (screenCapture) {
-            logger15.info("[Test] Screen capture available");
-            logger15.info(`[Test] Screen size: ${screenCapture.width}x${screenCapture.height}`);
-            logger15.info(`[Test] Tiles: ${screenCapture.tiles.length}`);
+            logger16.info("[Test] Screen capture available");
+            logger16.info(`[Test] Screen size: ${screenCapture.width}x${screenCapture.height}`);
+            logger16.info(`[Test] Tiles: ${screenCapture.tiles.length}`);
           }
         }
-        logger15.info("[Test] ✅ Florence-2 model test passed");
+        logger16.info("[Test] ✅ Florence-2 model test passed");
       }
     },
     {
       name: "OCR service functionality",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing OCR service...");
+        logger16.info("[Test] Testing OCR service...");
         const visionService = runtime.getService(VisionServiceType.VISION);
         if (!visionService) {
           throw new Error("Vision service not found");
         }
         const ocrEnabled = runtime.getSetting("OCR_ENABLED") === "true" || runtime.getSetting("VISION_OCR_ENABLED") === "true";
         if (!ocrEnabled) {
-          logger15.info("[Test] OCR is disabled, skipping test");
+          logger16.info("[Test] OCR is disabled, skipping test");
           return;
         }
         const mode = visionService.getVisionMode();
@@ -6135,18 +6378,18 @@ class VisionRuntimeTestSuite {
           if (enhancedScene?.screenAnalysis) {
             const ocrText = enhancedScene.screenAnalysis.fullScreenOCR;
             if (ocrText) {
-              logger15.info(`[Test] OCR extracted ${ocrText.length} characters`);
-              logger15.info(`[Test] OCR sample: ${ocrText.substring(0, 100)}...`);
+              logger16.info(`[Test] OCR extracted ${ocrText.length} characters`);
+              logger16.info(`[Test] OCR sample: ${ocrText.substring(0, 100)}...`);
             }
           }
         }
-        logger15.info("[Test] ✅ OCR service test passed");
+        logger16.info("[Test] ✅ OCR service test passed");
       }
     },
     {
       name: "Entity tracking system",
       fn: async (runtime) => {
-        logger15.info("[Test] Testing entity tracking...");
+        logger16.info("[Test] Testing entity tracking...");
         const visionService = runtime.getService(VisionServiceType.VISION);
         if (!visionService) {
           throw new Error("Vision service not found");
@@ -6156,14 +6399,14 @@ class VisionRuntimeTestSuite {
           throw new Error("Entity tracker not found");
         }
         const entities = entityTracker.getActiveEntities();
-        logger15.info(`[Test] Active entities: ${entities.length}`);
+        logger16.info(`[Test] Active entities: ${entities.length}`);
         for (const entity of entities) {
           if (!entity.id || !entity.entityType || !entity.lastSeen) {
             throw new Error("Entity missing required fields");
           }
-          logger15.info(`[Test] Entity ${entity.id}: type=${entity.entityType}, tracked=${entity.lastSeen - entity.firstSeen}ms`);
+          logger16.info(`[Test] Entity ${entity.id}: type=${entity.entityType}, tracked=${entity.lastSeen - entity.firstSeen}ms`);
         }
-        logger15.info("[Test] ✅ Entity tracking test passed");
+        logger16.info("[Test] ✅ Entity tracking test passed");
       }
     }
   ];
@@ -6176,7 +6419,7 @@ import { promisify as promisify4 } from "node:util";
 // src/tests/test-pattern-generator.ts
 import * as fs5 from "node:fs/promises";
 import * as path7 from "node:path";
-import { logger as logger16 } from "@elizaos/core";
+import { logger as logger17 } from "@elizaos/core";
 import sharp5 from "sharp";
 function generateGrid(width, height, spacing = 100) {
   const lines = [];
@@ -6286,7 +6529,7 @@ async function savePattern(buffer, filename) {
   await fs5.mkdir(outputDir, { recursive: true });
   const filepath = path7.join(outputDir, filename);
   await fs5.writeFile(filepath, buffer);
-  logger16.info(`[TestPatternGenerator] Saved test pattern to ${filepath}`);
+  logger17.info(`[TestPatternGenerator] Saved test pattern to ${filepath}`);
   return filepath;
 }
 function verifyQuadrantNumbers(ocrText) {
@@ -6356,7 +6599,7 @@ class VisionWorkerE2ETestSuite {
             frameCount++;
             lastTimestamp = scene.timestamp;
           }
-          await new Promise((resolve) => setImmediate(resolve));
+          await new Promise((resolve2) => setImmediate(resolve2));
         }
         const totalTime = (Date.now() - startTime) / 1000;
         const avgFPS = frameCount / totalTime;
@@ -6385,7 +6628,7 @@ class VisionWorkerE2ETestSuite {
         await displayTestPattern(patternPath);
         try {
           console.log("Waiting for OCR processing...");
-          await new Promise((resolve) => setTimeout(resolve, 3000));
+          await new Promise((resolve2) => setTimeout(resolve2, 3000));
           const scene = await visionService.getEnhancedSceneDescription();
           const ocrText = scene?.screenAnalysis?.fullScreenOCR || "";
           console.log(`OCR detected text: "${ocrText.substring(0, 100)}..."`);
@@ -6424,7 +6667,7 @@ class VisionWorkerE2ETestSuite {
           if (scene?.screenCapture) {
             console.log(`  Screen: ${scene.screenCapture.width}x${scene.screenCapture.height}`);
           }
-          await new Promise((resolve) => setTimeout(resolve, 500));
+          await new Promise((resolve2) => setTimeout(resolve2, 500));
         }
         console.log(`✓ Monitored ${displayCount} displays`);
       }
@@ -6469,7 +6712,7 @@ Current stats:`);
               console.log(`  OCR detections: ${stats.ocrDetections}`);
               console.log(`  Florence-2 detections: ${stats.florence2Detections}`);
             }
-            await new Promise((resolve) => setTimeout(resolve, 100));
+            await new Promise((resolve2) => setTimeout(resolve2, 100));
           }
           const totalTime = (Date.now() - startTime) / 1000;
           console.log(`
@@ -6520,7 +6763,7 @@ async function displayTestPattern(imagePath) {
     } else if (platform === "win32") {
       await execAsync4(`start "" "${imagePath}"`);
     }
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve2) => setTimeout(resolve2, 1000));
   } catch (error) {
     console.warn("Could not display test pattern:", error);
   }
@@ -6553,15 +6796,19 @@ var visionPlugin = {
   description: "Provides visual perception through camera integration and scene analysis",
   services: [VisionService],
   providers: [visionProvider],
-  actions: [
-    describeSceneAction,
-    captureImageAction,
-    setVisionModeAction,
-    nameEntityAction,
-    identifyPersonAction,
-    trackEntityAction
-  ],
+  actions: [...promoteSubactionsToActions(visionAction)],
   tests: testSuites,
+  autoEnable: {
+    shouldEnable: (_env, config) => {
+      const f = config?.features?.vision;
+      const featureOn = f === true || typeof f === "object" && f !== null && f.enabled !== false;
+      if (featureOn)
+        return true;
+      const media = config?.media;
+      const visionMedia = media?.vision;
+      return Boolean(visionMedia && visionMedia.enabled !== false && typeof visionMedia.provider === "string" && visionMedia.provider.length > 0);
+    }
+  },
   init: async (_config, _runtime) => {}
 };
 var src_default = visionPlugin;
@@ -6570,4 +6817,4 @@ export {
   src_default as default
 };
 
-//# debugId=08C3A6DFE8F9170A64756E2164756E21
+//# debugId=177A2977D034662964756E2164756E21