@elizaos/plugin-vision 1.2.1

package/dist/action.js

@@ -0,0 +1,1212 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackEntityAction = exports.identifyPersonAction = exports.nameEntityAction = exports.setVisionModeAction = exports.killAutonomousAction = exports.captureImageAction = exports.describeSceneAction = void 0;
+// Vision actions for scene analysis and image capture
+var core_1 = require("@elizaos/core");
+var types_1 = require("./types");
+// Helper function to save execution record to message feed
+function saveExecutionRecord(runtime, messageContext, thought, text, actions, attachments) {
+    return __awaiter(this, void 0, void 0, function () {
+        var memory;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    memory = {
+                        id: (0, core_1.createUniqueUuid)(runtime, "vision-record-".concat(Date.now())),
+                        content: {
+                            text: text,
+                            thought: thought,
+                            actions: actions || ['VISION_ANALYSIS'],
+                            attachments: attachments,
+                        },
+                        entityId: (0, core_1.createUniqueUuid)(runtime, runtime.agentId),
+                        agentId: runtime.agentId,
+                        roomId: messageContext.roomId,
+                        worldId: messageContext.worldId,
+                        createdAt: Date.now(),
+                    };
+                    return [4 /*yield*/, runtime.createMemory(memory, 'messages')];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.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: function (runtime, _message, _state) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService;
+        return __generator(this, function (_a) {
+            visionService = runtime.getService('VISION');
+            return [2 /*return*/, !!visionService && visionService.isActive()];
+        });
+    }); },
+    handler: function (runtime, message, _state, _options, callback, _responses) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService, thought, text, scene, cameraInfo, thought_1, text_1, peopleCount, objectCount, timestamp, description, facingData, facingDescriptions, objectTypes, objectDescriptions, thought, text, error_1, thought, text;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    visionService = runtime.getService('VISION');
+                    if (!(!visionService || !visionService.isActive())) return [3 /*break*/, 4];
+                    thought = 'Vision service is not available or no camera is connected.';
+                    text = 'I cannot see anything right now. No camera is available.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['DESCRIBE_SCENE'])];
+                case 1:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 3];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['DESCRIBE_SCENE'],
+                        })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/, {
+                        text: 'Vision service unavailable - cannot analyze scene',
+                        values: {
+                            success: false,
+                            visionAvailable: false,
+                            error: 'Vision service not available',
+                        },
+                        data: {
+                            actionName: 'DESCRIBE_SCENE',
+                            error: 'Vision service not available or no camera connected',
+                        },
+                    }];
+                case 4:
+                    _a.trys.push([4, 13, , 17]);
+                    return [4 /*yield*/, visionService.getSceneDescription()];
+                case 5:
+                    scene = _a.sent();
+                    cameraInfo = visionService.getCameraInfo();
+                    if (!!scene) return [3 /*break*/, 9];
+                    thought_1 = 'Camera is connected but no scene has been analyzed yet.';
+                    text_1 = "Camera \"".concat(cameraInfo === null || cameraInfo === void 0 ? void 0 : cameraInfo.name, "\" is connected, but I haven't analyzed any scenes yet. Please wait a moment.");
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_1, text_1, ['DESCRIBE_SCENE'])];
+                case 6:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 8];
+                    return [4 /*yield*/, callback({
+                            thought: thought_1,
+                            text: text_1,
+                            actions: ['DESCRIBE_SCENE'],
+                        })];
+                case 7:
+                    _a.sent();
+                    _a.label = 8;
+                case 8: return [2 /*return*/, {
+                        text: 'Camera connected but no scene analyzed yet',
+                        values: {
+                            success: false,
+                            visionAvailable: true,
+                            sceneAnalyzed: false,
+                            cameraName: cameraInfo === null || cameraInfo === void 0 ? void 0 : cameraInfo.name,
+                        },
+                        data: {
+                            actionName: 'DESCRIBE_SCENE',
+                            cameraInfo: cameraInfo,
+                            sceneStatus: 'not_analyzed',
+                        },
+                    }];
+                case 9:
+                    peopleCount = scene.people.length;
+                    objectCount = scene.objects.length;
+                    timestamp = new Date(scene.timestamp).toLocaleString();
+                    description = "Looking through ".concat((cameraInfo === null || cameraInfo === void 0 ? void 0 : cameraInfo.name) || 'the camera', ", ");
+                    description += scene.description;
+                    if (peopleCount > 0) {
+                        description += "\n\nI can see ".concat(peopleCount, " ").concat(peopleCount === 1 ? 'person' : 'people');
+                        facingData = scene.people.reduce(function (acc, person) {
+                            if (person.facing && person.facing !== 'unknown') {
+                                acc[person.facing] = (acc[person.facing] || 0) + 1;
+                            }
+                            return acc;
+                        }, {});
+                        if (Object.keys(facingData).length > 0) {
+                            facingDescriptions = Object.entries(facingData).map(function (_a) {
+                                var direction = _a[0], count = _a[1];
+                                return "".concat(count, " facing ").concat(direction);
+                            });
+                            description += " (".concat(facingDescriptions.join(', '), ")");
+                        }
+                        description += '.';
+                    }
+                    if (objectCount > 0) {
+                        objectTypes = scene.objects.reduce(function (acc, obj) {
+                            acc[obj.type] = (acc[obj.type] || 0) + 1;
+                            return acc;
+                        }, {});
+                        objectDescriptions = Object.entries(objectTypes).map(function (_a) {
+                            var type = _a[0], count = _a[1];
+                            return "".concat(count, " ").concat(type).concat(count > 1 ? 's' : '');
+                        });
+                        description += "\n\nObjects detected: ".concat(objectDescriptions.join(', '), ".");
+                    }
+                    if (scene.sceneChanged && scene.changePercentage) {
+                        description += "\n\n(Scene changed by ".concat(scene.changePercentage.toFixed(1), "% since last analysis)");
+                    }
+                    thought = "Analyzed the visual scene at ".concat(timestamp, ".");
+                    text = description;
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['DESCRIBE_SCENE'])];
+                case 10:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 12];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['DESCRIBE_SCENE'],
+                        })];
+                case 11:
+                    _a.sent();
+                    _a.label = 12;
+                case 12: return [2 /*return*/, {
+                        text: description,
+                        values: {
+                            success: true,
+                            visionAvailable: true,
+                            sceneAnalyzed: true,
+                            peopleCount: peopleCount,
+                            objectCount: objectCount,
+                            cameraName: cameraInfo === null || cameraInfo === void 0 ? void 0 : cameraInfo.name,
+                            sceneChanged: scene.sceneChanged,
+                            changePercentage: scene.changePercentage,
+                        },
+                        data: {
+                            actionName: 'DESCRIBE_SCENE',
+                            scene: scene,
+                            cameraInfo: cameraInfo,
+                            timestamp: timestamp,
+                            description: description,
+                        },
+                    }];
+                case 13:
+                    error_1 = _a.sent();
+                    core_1.logger.error('[describeSceneAction] Error analyzing scene:', error_1);
+                    thought = 'An error occurred while trying to analyze the visual scene.';
+                    text = "Error analyzing scene: ".concat(error_1.message);
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['DESCRIBE_SCENE'])];
+                case 14:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 16];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['DESCRIBE_SCENE'],
+                        })];
+                case 15:
+                    _a.sent();
+                    _a.label = 16;
+                case 16: return [2 /*return*/, {
+                        text: 'Error analyzing scene',
+                        values: {
+                            success: false,
+                            visionAvailable: true,
+                            error: true,
+                            errorMessage: error_1.message,
+                        },
+                        data: {
+                            actionName: 'DESCRIBE_SCENE',
+                            error: error_1.message,
+                            errorType: 'analysis_error',
+                        },
+                    }];
+                case 17: return [2 /*return*/];
+            }
+        });
+    }); },
+    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.',
+                },
+            },
+        ],
+    ],
+};
+exports.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.',
+    enabled: false, // Disabled by default - privacy-sensitive, can capture images
+    validate: function (runtime, _message, _state) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService;
+        return __generator(this, function (_a) {
+            visionService = runtime.getService('VISION');
+            return [2 /*return*/, !!visionService && visionService.isActive()];
+        });
+    }); },
+    handler: function (runtime, message, _state, _options, callback, _responses) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService, thought, text, imageBuffer, cameraInfo, thought_2, text_2, attachmentId, timestamp, imageAttachment, thought, text, error_2, thought, text;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    visionService = runtime.getService('VISION');
+                    if (!(!visionService || !visionService.isActive())) return [3 /*break*/, 4];
+                    thought = 'Vision service is not available or no camera is connected.';
+                    text = 'I cannot capture an image right now. No camera is available.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['CAPTURE_IMAGE'])];
+                case 1:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 3];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['CAPTURE_IMAGE'],
+                        })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/, {
+                        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',
+                        },
+                    }];
+                case 4:
+                    _a.trys.push([4, 13, , 17]);
+                    return [4 /*yield*/, visionService.captureImage()];
+                case 5:
+                    imageBuffer = _a.sent();
+                    cameraInfo = visionService.getCameraInfo();
+                    if (!!imageBuffer) return [3 /*break*/, 9];
+                    thought_2 = 'Failed to capture image from camera.';
+                    text_2 = 'I could not capture an image from the camera. Please try again.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_2, text_2, ['CAPTURE_IMAGE'])];
+                case 6:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 8];
+                    return [4 /*yield*/, callback({
+                            thought: thought_2,
+                            text: text_2,
+                            actions: ['CAPTURE_IMAGE'],
+                        })];
+                case 7:
+                    _a.sent();
+                    _a.label = 8;
+                case 8: return [2 /*return*/, {
+                        text: 'Failed to capture image from camera',
+                        values: {
+                            success: false,
+                            visionAvailable: true,
+                            captureSuccess: false,
+                        },
+                        data: {
+                            actionName: 'CAPTURE_IMAGE',
+                            error: 'Camera capture failed',
+                            cameraInfo: cameraInfo,
+                        },
+                    }];
+                case 9:
+                    attachmentId = (0, core_1.createUniqueUuid)(runtime, "capture-".concat(Date.now()));
+                    timestamp = new Date().toISOString();
+                    imageAttachment = {
+                        id: attachmentId,
+                        title: "Camera Capture - ".concat(timestamp),
+                        contentType: core_1.ContentType.IMAGE,
+                        source: "camera:".concat((cameraInfo === null || cameraInfo === void 0 ? void 0 : cameraInfo.name) || 'unknown'),
+                        url: "data:image/jpeg;base64,".concat(imageBuffer.toString('base64')),
+                    };
+                    thought = "Captured an image from camera \"".concat(cameraInfo === null || cameraInfo === void 0 ? void 0 : cameraInfo.name, "\".");
+                    text = "I've captured an image from the camera at ".concat(timestamp, ".");
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['CAPTURE_IMAGE'], [imageAttachment])];
+                case 10:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 12];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['CAPTURE_IMAGE'],
+                            attachments: [imageAttachment],
+                        })];
+                case 11:
+                    _a.sent();
+                    _a.label = 12;
+                case 12: return [2 /*return*/, {
+                        text: "I've captured an image from the camera at ".concat(timestamp, "."),
+                        values: {
+                            success: true,
+                            visionAvailable: true,
+                            captureSuccess: true,
+                            cameraName: cameraInfo === null || cameraInfo === void 0 ? void 0 : cameraInfo.name,
+                            timestamp: timestamp,
+                        },
+                        data: {
+                            actionName: 'CAPTURE_IMAGE',
+                            imageAttachment: imageAttachment,
+                            cameraInfo: cameraInfo,
+                            timestamp: timestamp,
+                        },
+                    }];
+                case 13:
+                    error_2 = _a.sent();
+                    core_1.logger.error('[captureImageAction] Error capturing image:', error_2);
+                    thought = 'An error occurred while trying to capture an image.';
+                    text = "Error capturing image: ".concat(error_2.message);
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['CAPTURE_IMAGE'])];
+                case 14:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 16];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['CAPTURE_IMAGE'],
+                        })];
+                case 15:
+                    _a.sent();
+                    _a.label = 16;
+                case 16: return [2 /*return*/, {
+                        text: 'Error capturing image',
+                        values: {
+                            success: false,
+                            visionAvailable: true,
+                            error: true,
+                            errorMessage: error_2.message,
+                        },
+                        data: {
+                            actionName: 'CAPTURE_IMAGE',
+                            error: error_2.message,
+                            errorType: 'capture_error',
+                        },
+                    }];
+                case 17: return [2 /*return*/];
+            }
+        });
+    }); },
+    examples: [
+        // Multi-action: Describe scene then capture image
+        [
+            { 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'],
+                },
+            },
+        ],
+    ],
+};
+exports.killAutonomousAction = {
+    name: 'KILL_AUTONOMOUS',
+    similes: ['STOP_AUTONOMOUS', 'HALT_AUTONOMOUS', 'KILL_AUTO_LOOP'],
+    description: 'Stops the autonomous agent loop for debugging purposes.',
+    enabled: false, // Disabled by default - potentially dangerous, can halt autonomous operations
+    validate: function (_runtime, _message, _state) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            // Always allow this action for debugging
+            return [2 /*return*/, true];
+        });
+    }); },
+    handler: function (runtime, message, _state, _options, callback, _responses) { return __awaiter(void 0, void 0, void 0, function () {
+        var autonomousService, thought, text, thought, text, error_3, thought, text;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 9, , 13]);
+                    autonomousService = runtime.getService('AUTONOMOUS');
+                    if (!(autonomousService && 'stop' in autonomousService)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, autonomousService.stop()];
+                case 1:
+                    _a.sent();
+                    thought = 'Successfully stopped the autonomous agent loop.';
+                    text = 'Autonomous loop has been killed. The agent will no longer run autonomously until restarted.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['KILL_AUTONOMOUS'])];
+                case 2:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 4];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['KILL_AUTONOMOUS'],
+                        })];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4: return [3 /*break*/, 8];
+                case 5:
+                    thought = 'Autonomous service not found or already stopped.';
+                    text = 'No autonomous loop was running or the service could not be found.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['KILL_AUTONOMOUS'])];
+                case 6:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 8];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['KILL_AUTONOMOUS'],
+                        })];
+                case 7:
+                    _a.sent();
+                    _a.label = 8;
+                case 8: return [3 /*break*/, 13];
+                case 9:
+                    error_3 = _a.sent();
+                    core_1.logger.error('[killAutonomousAction] Error stopping autonomous service:', error_3);
+                    thought = 'An error occurred while trying to stop the autonomous loop.';
+                    text = "Error stopping autonomous loop: ".concat(error_3.message);
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['KILL_AUTONOMOUS'])];
+                case 10:
+                    _a.sent();
+                    if (!callback) return [3 /*break*/, 12];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['KILL_AUTONOMOUS'],
+                        })];
+                case 11:
+                    _a.sent();
+                    _a.label = 12;
+                case 12: return [3 /*break*/, 13];
+                case 13: return [2 /*return*/];
+            }
+        });
+    }); },
+    examples: [
+        [
+            { name: 'user', content: { text: 'kill the autonomous loop' } },
+            {
+                name: 'agent',
+                content: {
+                    actions: ['KILL_AUTONOMOUS'],
+                    thought: 'The user wants to stop the autonomous agent loop for debugging.',
+                    text: 'Autonomous loop has been killed. The agent will no longer run autonomously until restarted.',
+                },
+            },
+        ],
+        [
+            { name: 'user', content: { text: 'stop autonomous mode' } },
+            {
+                name: 'agent',
+                content: {
+                    actions: ['KILL_AUTONOMOUS'],
+                },
+            },
+        ],
+    ],
+};
+exports.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: function (runtime, _message, _state) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService;
+        return __generator(this, function (_a) {
+            visionService = runtime.getService('VISION');
+            return [2 /*return*/, visionService !== null];
+        });
+    }); },
+    handler: function (runtime, message, _state, _options, callback, _responses) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService, thought, text, messageText, newMode, thought_3, text_3, currentMode, thought, text, error_4, thought, text;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    visionService = runtime.getService('VISION');
+                    if (!!visionService) return [3 /*break*/, 4];
+                    thought = 'Vision service is not available.';
+                    text = 'I cannot change vision mode because the vision service is not available.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['SET_VISION_MODE'])];
+                case 1:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 3];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['SET_VISION_MODE'],
+                        })];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3: return [2 /*return*/];
+                case 4:
+                    _b.trys.push([4, 13, , 17]);
+                    messageText = ((_a = message.content.text) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+                    newMode = null;
+                    if (messageText.includes('off') || messageText.includes('disable')) {
+                        newMode = types_1.VisionMode.OFF;
+                    }
+                    else if (messageText.includes('both')) {
+                        newMode = types_1.VisionMode.BOTH;
+                    }
+                    else if (messageText.includes('screen')) {
+                        newMode = types_1.VisionMode.SCREEN;
+                    }
+                    else if (messageText.includes('camera')) {
+                        newMode = types_1.VisionMode.CAMERA;
+                    }
+                    if (!!newMode) return [3 /*break*/, 8];
+                    thought_3 = 'Could not determine the desired vision mode from the message.';
+                    text_3 = 'Please specify the vision mode: OFF, CAMERA, SCREEN, or BOTH.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_3, text_3, ['SET_VISION_MODE'])];
+                case 5:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 7];
+                    return [4 /*yield*/, callback({
+                            thought: thought_3,
+                            text: text_3,
+                            actions: ['SET_VISION_MODE'],
+                        })];
+                case 6:
+                    _b.sent();
+                    _b.label = 7;
+                case 7: return [2 /*return*/];
+                case 8:
+                    currentMode = visionService.getVisionMode();
+                    return [4 /*yield*/, visionService.setVisionMode(newMode)];
+                case 9:
+                    _b.sent();
+                    thought = "Changed vision mode from ".concat(currentMode, " to ").concat(newMode, ".");
+                    text = '';
+                    switch (newMode) {
+                        case types_1.VisionMode.OFF:
+                            text = 'Vision has been disabled. I will no longer process visual input.';
+                            break;
+                        case types_1.VisionMode.CAMERA:
+                            text = 'Vision mode set to CAMERA only. I will process input from the camera.';
+                            break;
+                        case types_1.VisionMode.SCREEN:
+                            text = "Vision mode set to SCREEN only. I will analyze what's on your screen.";
+                            break;
+                        case types_1.VisionMode.BOTH:
+                            text = 'Vision mode set to BOTH. I will process input from both camera and screen.';
+                            break;
+                    }
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['SET_VISION_MODE'])];
+                case 10:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 12];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['SET_VISION_MODE'],
+                        })];
+                case 11:
+                    _b.sent();
+                    _b.label = 12;
+                case 12: return [3 /*break*/, 17];
+                case 13:
+                    error_4 = _b.sent();
+                    core_1.logger.error('[setVisionModeAction] Error changing vision mode:', error_4);
+                    thought = 'An error occurred while trying to change the vision mode.';
+                    text = "Error changing vision mode: ".concat(error_4.message);
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['SET_VISION_MODE'])];
+                case 14:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 16];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['SET_VISION_MODE'],
+                        })];
+                case 15:
+                    _b.sent();
+                    _b.label = 16;
+                case 16: return [3 /*break*/, 17];
+                case 17: return [2 /*return*/];
+            }
+        });
+    }); },
+    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.',
+                },
+            },
+        ],
+    ],
+};
+// Enhanced actions for entity tracking and face recognition
+exports.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: function (runtime, _message, _state) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService;
+        return __generator(this, function (_a) {
+            visionService = runtime.getService('VISION');
+            return [2 /*return*/, (visionService === null || visionService === void 0 ? void 0 : visionService.isActive()) || false];
+        });
+    }); },
+    handler: function (runtime, message, _state, _options, callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService, thought, text_4, scene, thought, text_5, text, nameMatch, thought, text_6, name_1, _worldId, entityTracker, activeEntities, people, thought, text_7, targetPerson, success, thought, text_8, thought, text_9, error_5, thought, text;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 26, , 30]);
+                    visionService = runtime.getService('VISION');
+                    if (!!visionService) return [3 /*break*/, 4];
+                    thought = 'Vision service is not available.';
+                    text_4 = 'I cannot name entities because the vision service is not available.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text_4, ['NAME_ENTITY'])];
+                case 1:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 3];
+                    return [4 /*yield*/, callback({ thought: thought, text: text_4, actions: ['NAME_ENTITY'] })];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3: return [2 /*return*/];
+                case 4: return [4 /*yield*/, visionService.getSceneDescription()];
+                case 5:
+                    scene = _b.sent();
+                    if (!(!scene || scene.people.length === 0)) return [3 /*break*/, 9];
+                    thought = 'No people visible to name.';
+                    text_5 = "I don't see any people in the current scene to name.";
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text_5, ['NAME_ENTITY'])];
+                case 6:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 8];
+                    return [4 /*yield*/, callback({ thought: thought, text: text_5, actions: ['NAME_ENTITY'] })];
+                case 7:
+                    _b.sent();
+                    _b.label = 8;
+                case 8: return [2 /*return*/];
+                case 9:
+                    text = ((_a = message.content.text) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+                    nameMatch = text.match(/(?:named?|call(?:ed)?|is)\s+(\w+)/i);
+                    if (!!nameMatch) return [3 /*break*/, 13];
+                    thought = 'Could not extract name from message.';
+                    text_6 = 'I couldn\'t understand what name to assign. Please say something like "The person is named Alice".';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text_6, ['NAME_ENTITY'])];
+                case 10:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 12];
+                    return [4 /*yield*/, callback({ thought: thought, text: text_6, actions: ['NAME_ENTITY'] })];
+                case 11:
+                    _b.sent();
+                    _b.label = 12;
+                case 12: return [2 /*return*/];
+                case 13:
+                    name_1 = nameMatch[1];
+                    _worldId = message.worldId || 'default-world';
+                    entityTracker = visionService.getEntityTracker();
+                    // Update entities
+                    return [4 /*yield*/, entityTracker.updateEntities(scene.objects, scene.people, undefined, runtime)];
+                case 14:
+                    // Update entities
+                    _b.sent();
+                    activeEntities = entityTracker.getActiveEntities();
+                    people = activeEntities.filter(function (e) { return e.entityType === 'person'; });
+                    if (!(people.length === 0)) return [3 /*break*/, 18];
+                    thought = 'No tracked people found.';
+                    text_7 = "I can see someone but haven't established tracking yet. Please try again in a moment.";
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text_7, ['NAME_ENTITY'])];
+                case 15:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 17];
+                    return [4 /*yield*/, callback({ thought: thought, text: text_7, actions: ['NAME_ENTITY'] })];
+                case 16:
+                    _b.sent();
+                    _b.label = 17;
+                case 17: return [2 /*return*/];
+                case 18:
+                    targetPerson = people[0];
+                    if (people.length > 1) {
+                        targetPerson = people.reduce(function (prev, curr) {
+                            var prevArea = prev.lastPosition.width * prev.lastPosition.height;
+                            var currArea = curr.lastPosition.width * curr.lastPosition.height;
+                            return currArea > prevArea ? curr : prev;
+                        });
+                    }
+                    success = entityTracker.assignNameToEntity(targetPerson.id, name_1);
+                    if (!success) return [3 /*break*/, 22];
+                    thought = "Named entity \"".concat(name_1, "\" and associated with person in scene.");
+                    text_8 = "I've identified the person as ".concat(name_1, ". I'll remember them for future interactions.");
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text_8, ['NAME_ENTITY'], undefined)];
+                case 19:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 21];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text_8,
+                            actions: ['NAME_ENTITY'],
+                            data: { entityId: targetPerson.id, name: name_1 },
+                        })];
+                case 20:
+                    _b.sent();
+                    _b.label = 21;
+                case 21:
+                    core_1.logger.info("[NameEntityAction] Assigned name \"".concat(name_1, "\" to entity ").concat(targetPerson.id));
+                    return [3 /*break*/, 25];
+                case 22:
+                    thought = 'Failed to assign name to entity.';
+                    text_9 = 'There was an error assigning the name. Please try again.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text_9, ['NAME_ENTITY'])];
+                case 23:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 25];
+                    return [4 /*yield*/, callback({ thought: thought, text: text_9, actions: ['NAME_ENTITY'] })];
+                case 24:
+                    _b.sent();
+                    _b.label = 25;
+                case 25: return [3 /*break*/, 30];
+                case 26:
+                    error_5 = _b.sent();
+                    core_1.logger.error('[NameEntityAction] Error:', error_5);
+                    thought = 'Failed to name entity.';
+                    text = "Sorry, I couldn't name the entity: ".concat(error_5 instanceof Error ? error_5.message : 'Unknown error');
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['NAME_ENTITY'])];
+                case 27:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 29];
+                    return [4 /*yield*/, callback({ thought: thought, text: text, actions: ['NAME_ENTITY'] })];
+                case 28:
+                    _b.sent();
+                    _b.label = 29;
+                case 29: return [3 /*break*/, 30];
+                case 30: return [2 /*return*/];
+            }
+        });
+    }); },
+};
+exports.identifyPersonAction = {
+    name: 'IDENTIFY_PERSON',
+    description: 'Identify a person in view if they have been seen before',
+    enabled: false, // Disabled by default - privacy-sensitive, can identify and recognize people
+    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?',
+                },
+            },
+            {
+                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'],
+                },
+            },
+        ],
+    ],
+    validate: function (runtime, _message, _state) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService;
+        return __generator(this, function (_a) {
+            visionService = runtime.getService('VISION');
+            return [2 /*return*/, (visionService === null || visionService === void 0 ? void 0 : visionService.isActive()) || false];
+        });
+    }); },
+    handler: function (runtime, message, _state, _options, callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService, thought_4, text_10, scene, thought_5, text_11, _worldId, entityTracker, activeEntities, people, thought_6, text_12, _responseText, recognizedCount, unknownCount, identifications, _i, people_1, person, name_2, duration, durationStr, personInfo, personInfo, recentlyLeft, _a, recentlyLeft_1, _b, entity, leftAt, timeAgo, timeStr, thought, text, error_6, thought, text;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 18, , 22]);
+                    visionService = runtime.getService('VISION');
+                    if (!!visionService) return [3 /*break*/, 4];
+                    thought_4 = 'Vision service is not available.';
+                    text_10 = 'I cannot identify people because the vision service is not available.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_4, text_10, ['IDENTIFY_PERSON'])];
+                case 1:
+                    _c.sent();
+                    if (!callback) return [3 /*break*/, 3];
+                    return [4 /*yield*/, callback({ thought: thought_4, text: text_10, actions: ['IDENTIFY_PERSON'] })];
+                case 2:
+                    _c.sent();
+                    _c.label = 3;
+                case 3: return [2 /*return*/];
+                case 4: return [4 /*yield*/, visionService.getSceneDescription()];
+                case 5:
+                    scene = _c.sent();
+                    if (!(!scene || scene.people.length === 0)) return [3 /*break*/, 9];
+                    thought_5 = 'No people visible to identify.';
+                    text_11 = "I don't see any people in the current scene.";
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_5, text_11, ['IDENTIFY_PERSON'])];
+                case 6:
+                    _c.sent();
+                    if (!callback) return [3 /*break*/, 8];
+                    return [4 /*yield*/, callback({ thought: thought_5, text: text_11, actions: ['IDENTIFY_PERSON'] })];
+                case 7:
+                    _c.sent();
+                    _c.label = 8;
+                case 8: return [2 /*return*/];
+                case 9:
+                    _worldId = message.worldId || 'default-world';
+                    entityTracker = visionService.getEntityTracker();
+                    // Update entities
+                    return [4 /*yield*/, entityTracker.updateEntities(scene.objects, scene.people, undefined, runtime)];
+                case 10:
+                    // Update entities
+                    _c.sent();
+                    activeEntities = entityTracker.getActiveEntities();
+                    people = activeEntities.filter(function (e) { return e.entityType === 'person'; });
+                    if (!(people.length === 0)) return [3 /*break*/, 14];
+                    thought_6 = 'No tracked people found.';
+                    text_12 = "I can see someone but I'm still processing their identity.";
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_6, text_12, ['IDENTIFY_PERSON'])];
+                case 11:
+                    _c.sent();
+                    if (!callback) return [3 /*break*/, 13];
+                    return [4 /*yield*/, callback({ thought: thought_6, text: text_12, actions: ['IDENTIFY_PERSON'] })];
+                case 12:
+                    _c.sent();
+                    _c.label = 13;
+                case 13: return [2 /*return*/];
+                case 14:
+                    _responseText = '';
+                    recognizedCount = 0;
+                    unknownCount = 0;
+                    identifications = [];
+                    for (_i = 0, people_1 = people; _i < people_1.length; _i++) {
+                        person = people_1[_i];
+                        name_2 = person.attributes.name;
+                        duration = Date.now() - person.firstSeen;
+                        durationStr = duration < 60000
+                            ? "".concat(Math.round(duration / 1000), " seconds")
+                            : "".concat(Math.round(duration / 60000), " minutes");
+                        if (name_2) {
+                            recognizedCount++;
+                            personInfo = "I can see ".concat(name_2, ". They've been here for ").concat(durationStr, ".");
+                            identifications.push(personInfo);
+                            // Add more context if available
+                            if (person.appearances.length > 5) {
+                                identifications.push("I've been tracking them consistently.");
+                            }
+                        }
+                        else {
+                            unknownCount++;
+                            personInfo = "I see an unidentified person who has been here for ".concat(durationStr, ".");
+                            identifications.push(personInfo);
+                            if (person.attributes.faceId) {
+                                identifications.push("I've captured their face profile but they haven't been named yet.");
+                            }
+                        }
+                    }
+                    recentlyLeft = entityTracker.getRecentlyLeft();
+                    if (recentlyLeft.length > 0) {
+                        identifications.push('\nRecently departed:');
+                        for (_a = 0, recentlyLeft_1 = recentlyLeft; _a < recentlyLeft_1.length; _a++) {
+                            _b = recentlyLeft_1[_a], entity = _b.entity, leftAt = _b.leftAt;
+                            if (entity.entityType === 'person' && entity.attributes.name) {
+                                timeAgo = Date.now() - leftAt;
+                                timeStr = timeAgo < 60000
+                                    ? "".concat(Math.round(timeAgo / 1000), " seconds ago")
+                                    : "".concat(Math.round(timeAgo / 60000), " minutes ago");
+                                identifications.push("".concat(entity.attributes.name, " left ").concat(timeStr, "."));
+                            }
+                        }
+                    }
+                    thought = "Identified ".concat(recognizedCount, " known people and ").concat(unknownCount, " unknown people.");
+                    text = identifications.join(' ');
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['IDENTIFY_PERSON'])];
+                case 15:
+                    _c.sent();
+                    if (!callback) return [3 /*break*/, 17];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: text,
+                            actions: ['IDENTIFY_PERSON'],
+                            data: { identifications: people },
+                        })];
+                case 16:
+                    _c.sent();
+                    _c.label = 17;
+                case 17: return [3 /*break*/, 22];
+                case 18:
+                    error_6 = _c.sent();
+                    core_1.logger.error('[identifyPersonAction] Error:', error_6);
+                    thought = 'Failed to identify people.';
+                    text = "Sorry, I couldn't identify people: ".concat(error_6 instanceof Error ? error_6.message : 'Unknown error');
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['IDENTIFY_PERSON'])];
+                case 19:
+                    _c.sent();
+                    if (!callback) return [3 /*break*/, 21];
+                    return [4 /*yield*/, callback({ thought: thought, text: text, actions: ['IDENTIFY_PERSON'] })];
+                case 20:
+                    _c.sent();
+                    _c.label = 21;
+                case 21: return [3 /*break*/, 22];
+                case 22: return [2 /*return*/];
+            }
+        });
+    }); },
+};
+exports.trackEntityAction = {
+    name: 'TRACK_ENTITY',
+    description: 'Start tracking a specific person or object in view',
+    enabled: false, // Disabled by default - privacy-sensitive, can track and monitor people
+    similes: [
+        'track the {description}',
+        'follow the {description}',
+        'keep an eye on the {description}',
+        'watch the {description}',
+    ],
+    examples: [
+        [
+            {
+                name: 'user',
+                content: {
+                    text: 'Track the person wearing the red shirt',
+                },
+            },
+            {
+                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'],
+                },
+            },
+        ],
+    ],
+    validate: function (runtime, _message, _state) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService;
+        return __generator(this, function (_a) {
+            visionService = runtime.getService('VISION');
+            return [2 /*return*/, (visionService === null || visionService === void 0 ? void 0 : visionService.isActive()) || false];
+        });
+    }); },
+    handler: function (runtime, message, _state, _options, callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var visionService, thought_7, text, scene, thought_8, text, _text, _worldId, entityTracker, stats, thought, summary, responseText, error_7, thought, text;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 14, , 18]);
+                    visionService = runtime.getService('VISION');
+                    if (!!visionService) return [3 /*break*/, 4];
+                    thought_7 = 'Vision service is not available.';
+                    text = 'I cannot track entities because the vision service is not available.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_7, text, ['TRACK_ENTITY'])];
+                case 1:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 3];
+                    return [4 /*yield*/, callback({ thought: thought_7, text: text, actions: ['TRACK_ENTITY'] })];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3: return [2 /*return*/];
+                case 4: return [4 /*yield*/, visionService.getSceneDescription()];
+                case 5:
+                    scene = _b.sent();
+                    if (!!scene) return [3 /*break*/, 9];
+                    thought_8 = 'No scene available for tracking.';
+                    text = 'I need a moment to process the visual scene before I can track entities.';
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought_8, text, ['TRACK_ENTITY'])];
+                case 6:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 8];
+                    return [4 /*yield*/, callback({ thought: thought_8, text: text, actions: ['TRACK_ENTITY'] })];
+                case 7:
+                    _b.sent();
+                    _b.label = 8;
+                case 8: return [2 /*return*/];
+                case 9:
+                    _text = ((_a = message.content.text) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+                    _worldId = message.worldId || 'default-world';
+                    entityTracker = visionService.getEntityTracker();
+                    // Update entities
+                    return [4 /*yield*/, entityTracker.updateEntities(scene.objects, scene.people, undefined, runtime)];
+                case 10:
+                    // Update entities
+                    _b.sent();
+                    stats = entityTracker.getStatistics();
+                    thought = "Tracking ".concat(stats.activeEntities, " entities in the scene.");
+                    summary = [
+                        "I'm now tracking ".concat(stats.activeEntities, " entities in the scene"),
+                        "(".concat(stats.people, " people, ").concat(stats.objects, " objects)."),
+                        'The visual tracking system will maintain persistent IDs for all entities',
+                        'and notify you of significant changes.',
+                    ];
+                    responseText = summary.join(' ');
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, responseText, ['TRACK_ENTITY'])];
+                case 11:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 13];
+                    return [4 /*yield*/, callback({
+                            thought: thought,
+                            text: responseText,
+                            actions: ['TRACK_ENTITY'],
+                            data: { entities: stats.activeEntities },
+                        })];
+                case 12:
+                    _b.sent();
+                    _b.label = 13;
+                case 13:
+                    core_1.logger.info("[TrackEntityAction] Tracking ".concat(stats.activeEntities, " entities"));
+                    return [3 /*break*/, 18];
+                case 14:
+                    error_7 = _b.sent();
+                    core_1.logger.error('[trackEntityAction] Error:', error_7);
+                    thought = 'Failed to track entities.';
+                    text = "Sorry, I couldn't track entities: ".concat(error_7 instanceof Error ? error_7.message : 'Unknown error');
+                    return [4 /*yield*/, saveExecutionRecord(runtime, message, thought, text, ['TRACK_ENTITY'])];
+                case 15:
+                    _b.sent();
+                    if (!callback) return [3 /*break*/, 17];
+                    return [4 /*yield*/, callback({ thought: thought, text: text, actions: ['TRACK_ENTITY'] })];
+                case 16:
+                    _b.sent();
+                    _b.label = 17;
+                case 17: return [3 /*break*/, 18];
+                case 18: return [2 /*return*/];
+            }
+        });
+    }); },
+};
+//# sourceMappingURL=action.js.map