@elizaos/plugin-vision 1.2.1

package/dist/vision-worker-manager.js

@@ -0,0 +1,668 @@
+"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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisionWorkerManager = void 0;
+var worker_threads_1 = require("worker_threads");
+var path = require("path");
+var util_1 = require("util");
+var core_1 = require("@elizaos/core");
+var VisionWorkerManager = /** @class */ (function () {
+    function VisionWorkerManager(config) {
+        // Workers
+        this.screenCaptureWorker = null;
+        this.florence2Worker = null;
+        this.ocrWorker = null;
+        // Buffer sizes
+        this.SCREEN_BUFFER_SIZE = 50 * 1024 * 1024; // 50MB for 4K screen
+        this.FLORENCE2_RESULTS_SIZE = 10 * 1024 * 1024; // 10MB for results
+        this.OCR_RESULTS_SIZE = 5 * 1024 * 1024; // 5MB for OCR text
+        // Atomic indices
+        this.FRAME_ID_INDEX = 0;
+        this.WIDTH_INDEX = 2;
+        this.HEIGHT_INDEX = 3;
+        this.DISPLAY_INDEX = 4;
+        this.TIMESTAMP_INDEX = 5;
+        this.DATA_OFFSET = 24;
+        // Worker stats
+        this.workerStats = new Map();
+        // Latest processed data cache
+        this.latestScreenCapture = null;
+        this.latestFlorence2Results = new Map();
+        this.latestOCRResult = null;
+        this.lastProcessedFrameId = -1;
+        // Worker restart tracking
+        this.restartAttempts = new Map();
+        this.MAX_RESTART_ATTEMPTS = 3;
+        this.config = config;
+        // Initialize shared buffers
+        this.screenBuffer = new SharedArrayBuffer(this.SCREEN_BUFFER_SIZE);
+        this.florence2ResultsBuffer = new SharedArrayBuffer(this.FLORENCE2_RESULTS_SIZE);
+        this.ocrResultsBuffer = new SharedArrayBuffer(this.OCR_RESULTS_SIZE);
+        // Create views
+        this.screenAtomicState = new Int32Array(this.screenBuffer, 0, 6);
+        this.screenDataView = new DataView(this.screenBuffer);
+        this.florence2ResultsView = new DataView(this.florence2ResultsBuffer);
+        this.ocrResultsView = new DataView(this.ocrResultsBuffer);
+    }
+    VisionWorkerManager.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        core_1.logger.info('[VisionWorkerManager] Initializing worker threads...');
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 7, , 8]);
+                        // Start screen capture worker
+                        return [4 /*yield*/, this.startScreenCaptureWorker()];
+                    case 2:
+                        // Start screen capture worker
+                        _a.sent();
+                        if (!this.config.florence2Enabled) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.startFlorence2Worker()];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (!this.config.ocrEnabled) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.startOCRWorker()];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        core_1.logger.info('[VisionWorkerManager] All workers initialized');
+                        return [3 /*break*/, 8];
+                    case 7:
+                        error_1 = _a.sent();
+                        core_1.logger.error('[VisionWorkerManager] Failed to initialize workers:', error_1);
+                        throw error_1;
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VisionWorkerManager.prototype.startScreenCaptureWorker = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var workerPath;
+            var _this = this;
+            return __generator(this, function (_a) {
+                workerPath = path.join(__dirname, 'workers', 'screen-capture-worker.js');
+                this.screenCaptureWorker = new worker_threads_1.Worker(workerPath, {
+                    workerData: {
+                        config: {
+                            displayIndex: this.config.displayIndex,
+                            captureAllDisplays: this.config.captureAllDisplays,
+                            targetFPS: this.config.targetScreenFPS,
+                            sharedBufferSize: this.SCREEN_BUFFER_SIZE,
+                        },
+                        sharedBuffer: this.screenBuffer,
+                    },
+                });
+                this.screenCaptureWorker.on('message', function (msg) {
+                    if (msg.type === 'fps') {
+                        _this.workerStats.set('screenCapture', {
+                            fps: msg.fps,
+                            frameCount: msg.frameCount,
+                            lastUpdate: Date.now(),
+                        });
+                    }
+                    else if (msg.type === 'error') {
+                        core_1.logger.error('[ScreenCaptureWorker] Error:', msg.error);
+                    }
+                    else if (msg.type === 'log') {
+                        // Handle worker log messages
+                        _this.handleWorkerLog('ScreenCaptureWorker', msg);
+                    }
+                });
+                this.screenCaptureWorker.on('error', function (error) {
+                    core_1.logger.error('[ScreenCaptureWorker] Worker error:', error);
+                    // Attempt to restart worker after error
+                    setTimeout(function () { return _this.restartScreenCaptureWorker(); }, 1000);
+                });
+                this.screenCaptureWorker.on('exit', function (code) {
+                    if (code !== 0) {
+                        core_1.logger.error("[ScreenCaptureWorker] Worker stopped with exit code ".concat(code));
+                        // Attempt to restart worker after crash
+                        setTimeout(function () { return _this.restartScreenCaptureWorker(); }, 1000);
+                    }
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    VisionWorkerManager.prototype.startFlorence2Worker = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var workerPath, priorityTiles, tileSize, estimatedCols, centerRow, centerCol, r, c;
+            var _this = this;
+            return __generator(this, function (_a) {
+                workerPath = path.join(__dirname, 'workers', 'florence2-worker.js');
+                priorityTiles = [];
+                tileSize = this.config.tileSize || 256;
+                estimatedCols = Math.ceil(1920 / tileSize);
+                centerRow = Math.floor(estimatedCols / 2);
+                centerCol = Math.floor(estimatedCols / 2);
+                // Add center and adjacent tiles as priority
+                for (r = centerRow - 1; r <= centerRow + 1; r++) {
+                    for (c = centerCol - 1; c <= centerCol + 1; c++) {
+                        if (r >= 0 && c >= 0) {
+                            priorityTiles.push(r * estimatedCols + c);
+                        }
+                    }
+                }
+                this.florence2Worker = new worker_threads_1.Worker(workerPath, {
+                    workerData: {
+                        config: {
+                            tileSize: this.config.tileSize || 256,
+                            priorityTiles: priorityTiles,
+                        },
+                        sharedBuffer: this.screenBuffer,
+                        resultsBuffer: this.florence2ResultsBuffer,
+                    },
+                });
+                this.florence2Worker.on('message', function (msg) {
+                    if (msg.type === 'fps') {
+                        _this.workerStats.set('florence2', {
+                            fps: msg.fps,
+                            frameCount: msg.frameCount,
+                            lastUpdate: Date.now(),
+                        });
+                    }
+                    else if (msg.type === 'tile_analyzed') {
+                        // Update latest results cache
+                        _this.updateFlorence2Cache(msg);
+                    }
+                    else if (msg.type === 'error') {
+                        core_1.logger.error('[Florence2Worker] Error:', msg.error);
+                    }
+                    else if (msg.type === 'log') {
+                        // Handle worker log messages
+                        _this.handleWorkerLog('Florence2Worker', msg);
+                    }
+                });
+                this.florence2Worker.on('error', function (error) {
+                    core_1.logger.error('[Florence2Worker] Worker error:', error);
+                    // Attempt to restart worker after error
+                    setTimeout(function () { return _this.restartFlorence2Worker(); }, 1000);
+                });
+                this.florence2Worker.on('exit', function (code) {
+                    if (code !== 0) {
+                        core_1.logger.error("[Florence2Worker] Worker stopped with exit code ".concat(code));
+                        // Attempt to restart worker after crash
+                        setTimeout(function () { return _this.restartFlorence2Worker(); }, 1000);
+                    }
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    VisionWorkerManager.prototype.startOCRWorker = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var workerPath;
+            var _this = this;
+            return __generator(this, function (_a) {
+                workerPath = path.join(__dirname, 'workers', 'ocr-worker.js');
+                this.ocrWorker = new worker_threads_1.Worker(workerPath, {
+                    workerData: {
+                        config: {
+                            processFullScreen: true,
+                            tileSize: this.config.tileSize || 256,
+                            textRegions: this.config.textRegions,
+                        },
+                        sharedBuffer: this.screenBuffer,
+                        resultsBuffer: this.ocrResultsBuffer,
+                    },
+                });
+                this.ocrWorker.on('message', function (msg) {
+                    if (msg.type === 'fps') {
+                        _this.workerStats.set('ocr', {
+                            fps: msg.fps,
+                            frameCount: msg.frameCount,
+                            lastUpdate: Date.now(),
+                        });
+                    }
+                    else if (msg.type === 'ocr_complete') {
+                        // Update latest OCR cache
+                        _this.updateOCRCache(msg);
+                    }
+                    else if (msg.type === 'error') {
+                        core_1.logger.error('[OCRWorker] Error:', msg.error);
+                    }
+                    else if (msg.type === 'log') {
+                        // Handle worker log messages
+                        _this.handleWorkerLog('OCRWorker', msg);
+                    }
+                });
+                this.ocrWorker.on('error', function (error) {
+                    core_1.logger.error('[OCRWorker] Worker error:', error);
+                    // Attempt to restart worker after error
+                    setTimeout(function () { return _this.restartOCRWorker(); }, 1000);
+                });
+                this.ocrWorker.on('exit', function (code) {
+                    if (code !== 0) {
+                        core_1.logger.error("[OCRWorker] Worker stopped with exit code ".concat(code));
+                        // Attempt to restart worker after crash
+                        setTimeout(function () { return _this.restartOCRWorker(); }, 1000);
+                    }
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    VisionWorkerManager.prototype.updateFlorence2Cache = function (msg) {
+        // Read result from shared buffer
+        try {
+            var tileId = msg.tileId;
+            var result = this.readFlorence2Result(tileId);
+            if (result) {
+                this.latestFlorence2Results.set(tileId, result);
+            }
+        }
+        catch (error) {
+            core_1.logger.error('[VisionWorkerManager] Failed to update Florence2 cache:', error);
+        }
+    };
+    VisionWorkerManager.prototype.updateOCRCache = function (_msg) {
+        // Read OCR result from shared buffer
+        try {
+            var result = this.readOCRResult();
+            if (result) {
+                this.latestOCRResult = result;
+            }
+        }
+        catch (error) {
+            core_1.logger.error('[VisionWorkerManager] Failed to update OCR cache:', error);
+        }
+    };
+    VisionWorkerManager.prototype.readFlorence2Result = function (tileId) {
+        try {
+            // Calculate tile index from ID
+            var match = tileId.match(/tile-(\d+)-(\d+)/);
+            if (!match) {
+                return null;
+            }
+            var row = parseInt(match[1], 10);
+            var col = parseInt(match[2], 10);
+            var tileIndex = row * 10 + col; // Assuming max 10 columns
+            var RESULTS_HEADER_SIZE = 16;
+            var MAX_RESULT_SIZE = 4096;
+            var offset = RESULTS_HEADER_SIZE + tileIndex * MAX_RESULT_SIZE;
+            // Read length
+            var length_1 = this.florence2ResultsView.getUint32(offset, true);
+            if (length_1 === 0 || length_1 > MAX_RESULT_SIZE - 4) {
+                return null;
+            }
+            // Read JSON data
+            var bytes = new Uint8Array(length_1);
+            for (var i = 0; i < length_1; i++) {
+                bytes[i] = this.florence2ResultsView.getUint8(offset + 4 + i);
+            }
+            var json = new util_1.TextDecoder().decode(bytes);
+            return JSON.parse(json);
+        }
+        catch (error) {
+            core_1.logger.error('[VisionWorkerManager] Failed to read Florence2 result:', error);
+            return null;
+        }
+    };
+    VisionWorkerManager.prototype.readOCRResult = function () {
+        try {
+            var RESULTS_HEADER_SIZE = 16;
+            var offset = RESULTS_HEADER_SIZE;
+            // Read length
+            var length_2 = this.ocrResultsView.getUint32(offset, true);
+            if (length_2 === 0) {
+                return null;
+            }
+            // Read frame ID and timestamp
+            var _frameId = this.ocrResultsView.getUint32(offset + 4, true);
+            var _timestamp = this.ocrResultsView.getFloat64(offset + 8, true);
+            // Read JSON data
+            var dataOffset = offset + 16;
+            var bytes = new Uint8Array(Math.min(length_2, 65536));
+            for (var i = 0; i < bytes.length; i++) {
+                bytes[i] = this.ocrResultsView.getUint8(dataOffset + i);
+            }
+            var json = new util_1.TextDecoder().decode(bytes);
+            return JSON.parse(json);
+        }
+        catch (error) {
+            core_1.logger.error('[VisionWorkerManager] Failed to read OCR result:', error);
+            return null;
+        }
+    };
+    // Public API - Non-blocking access to latest data
+    VisionWorkerManager.prototype.getLatestScreenCapture = function () {
+        // Read current frame metadata
+        var frameId = Atomics.load(this.screenAtomicState, this.FRAME_ID_INDEX);
+        if (frameId <= this.lastProcessedFrameId) {
+            return this.latestScreenCapture;
+        }
+        try {
+            var width = Atomics.load(this.screenAtomicState, this.WIDTH_INDEX);
+            var height = Atomics.load(this.screenAtomicState, this.HEIGHT_INDEX);
+            var _displayIndex = Atomics.load(this.screenAtomicState, this.DISPLAY_INDEX);
+            var timestamp = Atomics.load(this.screenAtomicState, this.TIMESTAMP_INDEX);
+            // Create screen capture object
+            this.latestScreenCapture = {
+                timestamp: timestamp,
+                width: width,
+                height: height,
+                data: Buffer.alloc(0), // We don't copy the full data for performance
+                tiles: this.generateTiles(width, height),
+            };
+            this.lastProcessedFrameId = frameId;
+        }
+        catch (error) {
+            core_1.logger.error('[VisionWorkerManager] Failed to read screen capture:', error);
+        }
+        return this.latestScreenCapture;
+    };
+    VisionWorkerManager.prototype.getLatestEnhancedScene = function () {
+        var _a;
+        var screenCapture = this.getLatestScreenCapture();
+        // Combine all Florence-2 results
+        var florence2Captions = [];
+        var allObjects = [];
+        var allTags = new Set();
+        this.latestFlorence2Results.forEach(function (result) {
+            if (result.caption) {
+                florence2Captions.push(result.caption);
+            }
+            if (result.objects) {
+                allObjects.push.apply(allObjects, result.objects);
+            }
+            if (result.tags) {
+                result.tags.forEach(function (tag) { return allTags.add(tag); });
+            }
+        });
+        var _tiles = this.generateTiles((screenCapture === null || screenCapture === void 0 ? void 0 : screenCapture.width) || 0, (screenCapture === null || screenCapture === void 0 ? void 0 : screenCapture.height) || 0);
+        return {
+            timestamp: Date.now(),
+            description: florence2Captions.join('. '),
+            objects: allObjects,
+            people: [], // Could be populated by TensorFlow worker
+            sceneChanged: true,
+            changePercentage: 100,
+            screenCapture: this.latestScreenCapture || undefined,
+            screenAnalysis: {
+                fullScreenOCR: (_a = this.latestOCRResult) === null || _a === void 0 ? void 0 : _a.fullText,
+                activeTile: {
+                    timestamp: Date.now(),
+                    florence2: this.latestFlorence2Results.values().next().value,
+                    ocr: this.latestOCRResult || undefined,
+                },
+                gridSummary: "".concat((screenCapture === null || screenCapture === void 0 ? void 0 : screenCapture.tiles.length) || 0, " tiles analyzed"),
+                uiElements: allObjects.map(function (obj) { return ({
+                    type: obj.label,
+                    text: '',
+                    position: obj.bbox,
+                }); }),
+            },
+        };
+    };
+    VisionWorkerManager.prototype.generateTiles = function (width, height) {
+        var tileSize = this.config.tileSize || 256;
+        var tiles = [];
+        for (var row = 0; row < Math.ceil(height / tileSize); row++) {
+            for (var col = 0; col < Math.ceil(width / tileSize); col++) {
+                var x = col * tileSize;
+                var y = row * tileSize;
+                tiles.push({
+                    id: "tile-".concat(row, "-").concat(col),
+                    row: row,
+                    col: col,
+                    x: x,
+                    y: y,
+                    width: Math.min(tileSize, width - x),
+                    height: Math.min(tileSize, height - y),
+                });
+            }
+        }
+        return tiles;
+    };
+    VisionWorkerManager.prototype.getWorkerStats = function () {
+        return new Map(this.workerStats);
+    };
+    VisionWorkerManager.prototype.setDisplayIndex = function (index) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.screenCaptureWorker) {
+                    this.screenCaptureWorker.postMessage({
+                        type: 'set_display',
+                        displayIndex: index,
+                    });
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    VisionWorkerManager.prototype.setTextRegions = function (regions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.ocrWorker) {
+                    this.ocrWorker.postMessage({
+                        type: 'update_regions',
+                        regions: regions,
+                    });
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    VisionWorkerManager.prototype.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var stopPromises;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        core_1.logger.info('[VisionWorkerManager] Stopping all workers...');
+                        stopPromises = [];
+                        if (this.screenCaptureWorker) {
+                            stopPromises.push(new Promise(function (resolve) {
+                                _this.screenCaptureWorker.once('exit', function () { return resolve(); });
+                                _this.screenCaptureWorker.postMessage({ type: 'stop' });
+                            }));
+                        }
+                        if (this.florence2Worker) {
+                            stopPromises.push(new Promise(function (resolve) {
+                                _this.florence2Worker.once('exit', function () { return resolve(); });
+                                _this.florence2Worker.postMessage({ type: 'stop' });
+                            }));
+                        }
+                        if (this.ocrWorker) {
+                            stopPromises.push(new Promise(function (resolve) {
+                                _this.ocrWorker.once('exit', function () { return resolve(); });
+                                _this.ocrWorker.postMessage({ type: 'stop' });
+                            }));
+                        }
+                        return [4 /*yield*/, Promise.all(stopPromises)];
+                    case 1:
+                        _a.sent();
+                        core_1.logger.info('[VisionWorkerManager] All workers stopped');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VisionWorkerManager.prototype.handleWorkerLog = function (workerName, msg) {
+        var level = msg.level, message = msg.message, args = msg.args;
+        var formattedMessage = "[".concat(workerName, "] ").concat(message);
+        switch (level) {
+            case 'info':
+                core_1.logger.info.apply(core_1.logger, __spreadArray([formattedMessage], args, false));
+                break;
+            case 'warn':
+                core_1.logger.warn.apply(core_1.logger, __spreadArray([formattedMessage], args, false));
+                break;
+            case 'error':
+                core_1.logger.error.apply(core_1.logger, __spreadArray([formattedMessage], args, false));
+                break;
+            case 'debug':
+                core_1.logger.debug.apply(core_1.logger, __spreadArray([formattedMessage], args, false));
+                break;
+        }
+    };
+    VisionWorkerManager.prototype.restartScreenCaptureWorker = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var attempts, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        attempts = this.restartAttempts.get('screenCapture') || 0;
+                        if (attempts >= this.MAX_RESTART_ATTEMPTS) {
+                            core_1.logger.error('[VisionWorkerManager] Max restart attempts reached for screen capture worker');
+                            return [2 /*return*/];
+                        }
+                        this.restartAttempts.set('screenCapture', attempts + 1);
+                        core_1.logger.info("[VisionWorkerManager] Restarting screen capture worker (attempt ".concat(attempts + 1, ")"));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        // Clean up existing worker
+                        if (this.screenCaptureWorker) {
+                            this.screenCaptureWorker.removeAllListeners();
+                            this.screenCaptureWorker = null;
+                        }
+                        // Start new worker
+                        return [4 /*yield*/, this.startScreenCaptureWorker()];
+                    case 2:
+                        // Start new worker
+                        _a.sent();
+                        // Reset restart counter on successful start
+                        this.restartAttempts.set('screenCapture', 0);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        core_1.logger.error('[VisionWorkerManager] Failed to restart screen capture worker:', error_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VisionWorkerManager.prototype.restartFlorence2Worker = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var attempts, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        attempts = this.restartAttempts.get('florence2') || 0;
+                        if (attempts >= this.MAX_RESTART_ATTEMPTS) {
+                            core_1.logger.error('[VisionWorkerManager] Max restart attempts reached for Florence2 worker');
+                            return [2 /*return*/];
+                        }
+                        this.restartAttempts.set('florence2', attempts + 1);
+                        core_1.logger.info("[VisionWorkerManager] Restarting Florence2 worker (attempt ".concat(attempts + 1, ")"));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        // Clean up existing worker
+                        if (this.florence2Worker) {
+                            this.florence2Worker.removeAllListeners();
+                            this.florence2Worker = null;
+                        }
+                        // Start new worker
+                        return [4 /*yield*/, this.startFlorence2Worker()];
+                    case 2:
+                        // Start new worker
+                        _a.sent();
+                        // Reset restart counter on successful start
+                        this.restartAttempts.set('florence2', 0);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_3 = _a.sent();
+                        core_1.logger.error('[VisionWorkerManager] Failed to restart Florence2 worker:', error_3);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    VisionWorkerManager.prototype.restartOCRWorker = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var attempts, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        attempts = this.restartAttempts.get('ocr') || 0;
+                        if (attempts >= this.MAX_RESTART_ATTEMPTS) {
+                            core_1.logger.error('[VisionWorkerManager] Max restart attempts reached for OCR worker');
+                            return [2 /*return*/];
+                        }
+                        this.restartAttempts.set('ocr', attempts + 1);
+                        core_1.logger.info("[VisionWorkerManager] Restarting OCR worker (attempt ".concat(attempts + 1, ")"));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        // Clean up existing worker
+                        if (this.ocrWorker) {
+                            this.ocrWorker.removeAllListeners();
+                            this.ocrWorker = null;
+                        }
+                        // Start new worker
+                        return [4 /*yield*/, this.startOCRWorker()];
+                    case 2:
+                        // Start new worker
+                        _a.sent();
+                        // Reset restart counter on successful start
+                        this.restartAttempts.set('ocr', 0);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_4 = _a.sent();
+                        core_1.logger.error('[VisionWorkerManager] Failed to restart OCR worker:', error_4);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return VisionWorkerManager;
+}());
+exports.VisionWorkerManager = VisionWorkerManager;
+//# sourceMappingURL=vision-worker-manager.js.map