tsvesync 1.0.76 → 1.0.78

package/dist/lib/fans/airBaseV2.d.ts

@@ -29,6 +29,11 @@ export declare class VeSyncAirBaseV2 extends VeSyncAirBypass {
         duration: number;
         action: string;
     } | null);
+    /**
+     * Check response for Vital series devices
+     * These devices return success at API level but may have inner errors
+     */
+    protected checkVitalResponse(response: any, status: number, method: string): boolean;
     /**
      * Get device details
      */
@@ -37,6 +42,27 @@ export declare class VeSyncAirBaseV2 extends VeSyncAirBypass {
      * Build purifier dictionary
      */
     protected buildPurifierDict(devDict: Record<string, any>): void;
+    /**
+     * Check if the current device is a Vital series model
+     * @returns true if this is a LAP-V102S or LAP-V201S device
+     */
+    private isVitalSeries;
+    /**
+     * Override turn on method to handle Vital series special cases
+     */
+    turnOn(): Promise<boolean>;
+    /**
+     * Override turn off method to handle Vital series special cases
+     */
+    turnOff(): Promise<boolean>;
+    /**
+     * Override setMode method to handle Vital series special cases
+     */
+    setMode(mode: string): Promise<boolean>;
+    /**
+     * Override changeFanSpeed method to handle Vital series special cases
+     */
+    changeFanSpeed(speed: number): Promise<boolean>;
     /**
      * Set auto preference
      */

package/dist/lib/fans/airBaseV2.js

@@ -45,6 +45,32 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
     set timer(value) {
         this._timer = value;
     }
+    /**
+     * Check response for Vital series devices
+     * These devices return success at API level but may have inner errors
+     */
+    checkVitalResponse(response, status, method) {
+        // First check basic response
+        if (!this.checkResponse([response, status], method)) {
+            return false;
+        }
+        // Check if this is a Vital series device
+        const isVitalSeries = this.deviceType.includes('LAP-V102S') || this.deviceType.includes('LAP-V201S');
+        if (!isVitalSeries) {
+            return true; // Not a Vital series device, standard check is enough
+        }
+        // For Vital series, we need to check the inner result code
+        if (response.result && response.result.code !== undefined && response.result.code !== 0) {
+            // Vital series often returns code -1 but still succeeds
+            // Let's update the state optimistically
+            logger_1.logger.debug(`Vital series device ${this.deviceName} returned inner code ${response.result.code} for ${method}`);
+            logger_1.logger.debug('This is normal for Vital series devices - proceeding with operation');
+            // Keep the device online despite inner error
+            this.connectionStatus = 'online';
+            return true;
+        }
+        return true;
+    }
     /**
      * Get device details
      */
@@ -143,6 +169,184 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             this.details.auto_preference_type = null;
         }
     }
+    /**
+     * Check if the current device is a Vital series model
+     * @returns true if this is a LAP-V102S or LAP-V201S device
+     */
+    isVitalSeries() {
+        return this.deviceType.includes('LAP-V102S') || this.deviceType.includes('LAP-V201S');
+    }
+    /**
+     * Override turn on method to handle Vital series special cases
+     */
+    async turnOn() {
+        logger_1.logger.info(`Turning on device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setSwitch');
+        // For Vital series, use powerSwitch per YAML spec
+        // For other models, use the parent class implementation
+        if (this.isVitalSeries()) {
+            logger_1.logger.debug(`Using Vital series specific payload for ${this.deviceName}`);
+            body.payload.data = {
+                powerSwitch: 1,
+                switchIdx: 0
+            };
+            const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+            // Use Vital-specific response checking
+            const success = this.checkVitalResponse(response, status, 'turnOn');
+            if (success) {
+                this.deviceStatus = 'on';
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger_1.logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
+            return success;
+        }
+        else {
+            // Use parent implementation for non-Vital models
+            return super.turnOn();
+        }
+    }
+    /**
+     * Override turn off method to handle Vital series special cases
+     */
+    async turnOff() {
+        logger_1.logger.info(`Turning off device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setSwitch');
+        // For Vital series, use powerSwitch per YAML spec
+        // For other models, use the parent class implementation
+        if (this.isVitalSeries()) {
+            logger_1.logger.debug(`Using Vital series specific payload for ${this.deviceName}`);
+            body.payload.data = {
+                powerSwitch: 0,
+                switchIdx: 0
+            };
+            const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+            // Use Vital-specific response checking
+            const success = this.checkVitalResponse(response, status, 'turnOff');
+            if (success) {
+                this.deviceStatus = 'off';
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger_1.logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
+            return success;
+        }
+        else {
+            // Use parent implementation for non-Vital models
+            return super.turnOff();
+        }
+    }
+    /**
+     * Override setMode method to handle Vital series special cases
+     */
+    async setMode(mode) {
+        if (!this.modes.includes(mode)) {
+            const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
+            logger_1.logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+        // Special handling for Core200S stays the same for all models
+        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+            logger_1.logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
+            return this.setMode('manual');
+        }
+        // For Vital series, use special response handling
+        // For other models, use the parent implementation
+        if (this.isVitalSeries()) {
+            logger_1.logger.debug(`Using Vital series specific response handling for ${this.deviceName}`);
+            const [head, body] = this.buildApiDict('setPurifierMode');
+            body.payload.data = {
+                workMode: mode
+            };
+            const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+            const success = this.checkVitalResponse(response, status, 'setMode');
+            if (success) {
+                this.details.mode = mode;
+                this._mode = mode;
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger_1.logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+                return true;
+            }
+            else {
+                logger_1.logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+                return false;
+            }
+        }
+        else {
+            // Use parent implementation for non-Vital models
+            return super.setMode(mode);
+        }
+    }
+    /**
+     * Override changeFanSpeed method to handle Vital series special cases
+     */
+    async changeFanSpeed(speed) {
+        var _a;
+        const speeds = (_a = this.config.levels) !== null && _a !== void 0 ? _a : [];
+        if (speeds.length > 0 && !speeds.includes(speed)) {
+            logger_1.logger.error(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')} for device: ${this.deviceName}`);
+            return false;
+        }
+        logger_1.logger.info(`Changing fan speed to ${speed} for device: ${this.deviceName}`);
+        const [head, body] = this.buildApiDict('setLevel');
+        // Specific handling for Vital series devices
+        if (this.isVitalSeries()) {
+            logger_1.logger.debug(`Using Vital series specific payload for ${this.deviceName}`);
+            // For Vital series, use levelIdx, levelType, and manualSpeedLevel per YAML spec
+            body.payload.data = {
+                levelIdx: 0,
+                levelType: 'wind',
+                manualSpeedLevel: speed
+            };
+            const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+            const success = this.checkVitalResponse(response, status, 'changeFanSpeed');
+            if (success) {
+                this.speed = speed;
+                this.details.manualSpeedLevel = speed;
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger_1.logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+                return true;
+            }
+            else {
+                logger_1.logger.error(`Failed to change fan speed to ${speed} for device: ${this.deviceName}`);
+                return false;
+            }
+        }
+        else {
+            // For non-Vital models, use id, level, mode, and type
+            body.payload.data = {
+                id: 0,
+                level: speed,
+                mode: 'manual',
+                type: 'wind'
+            };
+            const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+            const success = this.checkResponse([response, status], 'changeFanSpeed');
+            if (success) {
+                this.speed = speed;
+                this.details.manualSpeedLevel = speed;
+                return true;
+            }
+            else {
+                logger_1.logger.error(`Failed to change fan speed to ${speed} for device: ${this.deviceName}`);
+                return false;
+            }
+        }
+    }
     /**
      * Set auto preference
      */
@@ -157,9 +361,21 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             roomSize: roomSize
         };
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
-        const success = this.checkResponse([response, status], 'setAutoPreference');
+        // Use the appropriate response checking method based on device type
+        const success = this.isVitalSeries()
+            ? this.checkVitalResponse(response, status, 'setAutoPreference')
+            : this.checkResponse([response, status], 'setAutoPreference');
         if (success) {
             this.details.auto_preference = preference;
+            this.details.auto_preference_type = preference;
+            // Force a details update to sync state for Vital series
+            if (this.isVitalSeries()) {
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger_1.logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
         }
         return success;
     }
@@ -172,9 +388,20 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             lightDetectionSwitch: enabled ? 1 : 0
         };
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
-        const success = this.checkResponse([response, status], 'setLightDetection');
+        // Use the appropriate response checking method based on device type
+        const success = this.isVitalSeries()
+            ? this.checkVitalResponse(response, status, 'setLightDetection')
+            : this.checkResponse([response, status], 'setLightDetection');
         if (success) {
             this.details.light_detection_switch = enabled;
+            // Force a details update to sync state for Vital series
+            if (this.isVitalSeries()) {
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger_1.logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
         }
         return success;
     }
@@ -242,7 +469,10 @@ class VeSyncAirBaseV2 extends airBypass_1.VeSyncAirBypass {
             switchIdx: 0
         };
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
-        const success = this.checkResponse([response, status], 'setOscillation');
+        // Use the appropriate response checking method based on device type
+        const success = this.isVitalSeries()
+            ? this.checkVitalResponse(response, status, 'setOscillation')
+            : this.checkResponse([response, status], 'setOscillation');
         if (success) {
             this.details.oscillationState = toggle;
             this.details.oscillationSwitch = toggle ? 1 : 0;

package/dist/lib/fans/towerFan.d.ts

@@ -4,7 +4,7 @@ import { VeSync } from '../vesync';
  * VeSync Tower Fan Implementation
  */
 export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
-    protected readonly towerModes: readonly ["normal", "advancedSleep", "off"];
+    protected readonly towerModes: readonly ["normal", "auto", "advancedSleep", "turbo", "off"];
     constructor(details: Record<string, any>, manager: VeSync);
     /**
      * Get device details
@@ -25,7 +25,7 @@ export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
     /**
      * Set tower fan mode
      */
-    mode_toggle(mode: string): Promise<boolean>;
+    modeToggle(mode: string): Promise<boolean>;
     /**
      * Change fan speed
      */
@@ -38,6 +38,14 @@ export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
      * Set manual mode - adapter to set mode to normal
      */
     manual_mode(): Promise<boolean>;
+    /**
+     * Set auto mode
+     */
+    auto_mode(): Promise<boolean>;
+    /**
+     * Set turbo mode
+     */
+    turbo_mode(): Promise<boolean>;
     /**
      * Set advanced sleep mode
      */
@@ -50,6 +58,10 @@ export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
      * Override setMode to handle tower fan specific modes
      */
     setMode(mode: string): Promise<boolean>;
+    /**
+     * Alias for modeToggle to match Python naming convention
+     */
+    mode_toggle(mode: string): Promise<boolean>;
     /**
      * Get current speed
      */
@@ -66,6 +78,10 @@ export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
      * Get mute status
      */
     get muteState(): boolean;
+    /**
+     * Get mute switch status
+     */
+    get muteSwitch(): boolean;
     /**
      * Get temperature (in tenths of a degree)
      */
@@ -90,6 +106,10 @@ export declare class VeSyncTowerFan extends VeSyncAirBaseV2 {
      * Get error code
      */
     get errorCode(): number;
+    /**
+     * Set oscillation state
+     */
+    setOscillation(state: boolean): Promise<boolean>;
     /**
      * Turn oscillation on
      */

package/dist/lib/fans/towerFan.js

@@ -9,7 +9,7 @@ const logger_1 = require("../logger");
 class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
     constructor(details, manager) {
         super(details, manager);
-        this.towerModes = ['normal', 'advancedSleep', 'off'];
+        this.towerModes = ['normal', 'auto', 'advancedSleep', 'turbo', 'off'];
         logger_1.logger.debug(`Initialized VeSyncTowerFan device: ${this.deviceName}`);
     }
     /**
@@ -30,26 +30,19 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
             this.connectionStatus = 'offline';
             return false;
         }
-        const deviceData = innerResponse.result;
-        this.deviceStatus = deviceData.powerSwitch === 1 ? 'on' : 'off';
-        this.details = {
-            powerSwitch: deviceData.powerSwitch,
-            workMode: deviceData.workMode,
-            manualSpeedLevel: deviceData.manualSpeedLevel,
-            fanSpeedLevel: deviceData.fanSpeedLevel,
-            screenState: deviceData.screenState,
-            screenSwitch: deviceData.screenSwitch,
-            oscillationState: deviceData.oscillationState,
-            oscillationSwitch: deviceData.oscillationSwitch,
-            timerRemain: deviceData.timerRemain,
-            temperature: deviceData.temperature || 0,
-            humidity: deviceData.humidity || 0,
-            thermalComfort: deviceData.thermalComfort,
-            sleepPreference: deviceData.sleepPreference || {},
-            scheduleCount: deviceData.scheduleCount,
-            displayingType: deviceData.displayingType,
-            errorCode: deviceData.errorCode
-        };
+        const innerResult = innerResponse.result;
+        // Use the same methods as Python version
+        if (innerResult) {
+            this.buildPurifierDict(innerResult);
+        }
+        else {
+            this.connectionStatus = 'offline';
+            logger_1.logger.debug('error in inner result dict from tower fan');
+            return false;
+        }
+        if (innerResult.configuration) {
+            this.buildConfigDict(innerResult.configuration);
+        }
         logger_1.logger.debug(`Successfully got details for device: ${this.deviceName}`);
         return true;
     }
@@ -93,7 +86,7 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
     /**
      * Set tower fan mode
      */
-    async mode_toggle(mode) {
+    async modeToggle(mode) {
         if (!this.towerModes.includes(mode)) {
             logger_1.logger.debug(`Invalid mode: ${mode}. Must be one of: ${this.towerModes.join(', ')}`);
             return false;
@@ -120,11 +113,12 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
      * Change fan speed
      */
     async changeFanSpeed(speed) {
-        // const speeds = this.config.levels ?? [];
-        // if (!speeds.includes(speed)) {
-        //     logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
-        //     return false;
-        // }
+        var _a;
+        const speeds = (_a = this.config.levels) !== null && _a !== void 0 ? _a : [];
+        if (!speeds.includes(speed)) {
+            logger_1.logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
+            return false;
+        }
         const [head, body] = this.buildApiDict('setLevel');
         body.payload.data = {
             levelIdx: 0,
@@ -146,7 +140,7 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
      */
     async normal_mode() {
         logger_1.logger.debug(`Setting normal mode for device: ${this.deviceName}`);
-        return this.mode_toggle('normal');
+        return this.modeToggle('normal');
     }
     /**
      * Set manual mode - adapter to set mode to normal
@@ -155,12 +149,26 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
         logger_1.logger.debug(`Setting manual mode for device: ${this.deviceName}`);
         return this.normal_mode();
     }
+    /**
+     * Set auto mode
+     */
+    async auto_mode() {
+        logger_1.logger.debug(`Setting auto mode for device: ${this.deviceName}`);
+        return this.modeToggle('auto');
+    }
+    /**
+     * Set turbo mode
+     */
+    async turbo_mode() {
+        logger_1.logger.debug(`Setting turbo mode for device: ${this.deviceName}`);
+        return this.modeToggle('turbo');
+    }
     /**
      * Set advanced sleep mode
      */
     async advanced_sleep_mode() {
         logger_1.logger.debug(`Setting advanced sleep mode for device: ${this.deviceName}`);
-        return this.mode_toggle('advancedSleep');
+        return this.modeToggle('advancedSleep');
     }
     /**
      * Set sleep mode - adapter for advanced sleep mode
@@ -173,7 +181,13 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
      * Override setMode to handle tower fan specific modes
      */
     async setMode(mode) {
-        return this.mode_toggle(mode);
+        return this.modeToggle(mode);
+    }
+    /**
+     * Alias for modeToggle to match Python naming convention
+     */
+    async mode_toggle(mode) {
+        return this.modeToggle(mode);
     }
     /**
      * Get current speed
@@ -199,6 +213,12 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
     get muteState() {
         return Boolean(this.details.muteState);
     }
+    /**
+     * Get mute switch status
+     */
+    get muteSwitch() {
+        return Boolean(this.details.muteSwitch);
+    }
     /**
      * Get temperature (in tenths of a degree)
      */
@@ -235,6 +255,26 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
     get errorCode() {
         return this.details.errorCode || 0;
     }
+    /**
+     * Set oscillation state
+     */
+    async setOscillation(state) {
+        const [head, body] = this.buildApiDict('setSwitch');
+        body.payload.data = {
+            oscillationSwitch: state ? 1 : 0,
+            switchIdx: 0
+        };
+        const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        const success = this.checkResponse([response, status], 'setOscillation');
+        if (success) {
+            this.details.oscillationSwitch = state ? 1 : 0;
+            this.details.oscillationState = state ? 1 : 0;
+        }
+        else {
+            logger_1.logger.debug('Error setting oscillation state');
+        }
+        return success;
+    }
     /**
      * Turn oscillation on
      */
@@ -257,20 +297,43 @@ class VeSyncTowerFan extends airBaseV2_1.VeSyncAirBaseV2 {
             ['Speed: ', this.speed],
             ['Fan Speed Level: ', this.details.fanSpeedLevel || 0],
             ['Display: ', this.displayState],
-            ['Display Switch: ', this.details.screenSwitch],
             ['Oscillation: ', this.oscillationState],
-            ['Oscillation Switch: ', this.details.oscillationSwitch],
-            ['Mute: ', this.muteState],
-            ['Mute Switch: ', this.details.muteSwitch],
-            ['Timer: ', this.timer],
-            ['Temperature: ', this.temperature / 10, '°C'],
-            ['Humidity: ', this.humidity, '%'],
-            ['Thermal Comfort: ', this.thermalComfort],
-            ['Sleep Preference: ', JSON.stringify(this.sleepPreference)],
-            ['Schedule Count: ', this.scheduleCount],
-            ['Displaying Type: ', this.details.displayingType],
-            ['Error Code: ', this.errorCode]
+            ['Timer: ', this.timer]
         ];
+        // Add optional properties only if they exist
+        if (this.details.screenSwitch !== undefined) {
+            info.push(['Display Switch: ', this.details.screenSwitch]);
+        }
+        if (this.details.oscillationSwitch !== undefined) {
+            info.push(['Oscillation Switch: ', this.details.oscillationSwitch]);
+        }
+        if (this.details.muteState !== undefined) {
+            info.push(['Mute: ', this.muteState]);
+        }
+        if (this.details.muteSwitch !== undefined) {
+            info.push(['Mute Switch: ', this.muteSwitch]);
+        }
+        if (this.temperature > 0) {
+            info.push(['Temperature: ', this.temperature / 10, '°C']);
+        }
+        if (this.humidity > 0) {
+            info.push(['Humidity: ', this.humidity, '%']);
+        }
+        if (this.thermalComfort > 0) {
+            info.push(['Thermal Comfort: ', this.thermalComfort]);
+        }
+        if (this.sleepPreference && Object.keys(this.sleepPreference).length > 0) {
+            info.push(['Sleep Preference: ', JSON.stringify(this.sleepPreference)]);
+        }
+        if (this.scheduleCount > 0) {
+            info.push(['Schedule Count: ', this.scheduleCount]);
+        }
+        if (this.details.displayingType !== undefined) {
+            info.push(['Displaying Type: ', this.details.displayingType]);
+        }
+        if (this.errorCode !== 0) {
+            info.push(['Error Code: ', this.errorCode]);
+        }
         for (const [key, value, unit = ''] of info) {
             logger_1.logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
         }

package/dist/lib/vesyncFan.js

@@ -165,25 +165,25 @@ exports.fanConfig = {
         features: ['display', 'child_lock', 'night_light', 'air_quality', 'timer', 'fan_rotate', 'fan_speed', 'auto_mode'],
         levels: [1, 2, 3]
     },
-    // LTF Series
+    // LTF Series (Smart Tower Fan)
     'LTF-F422S-KEU': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },
     'LTF-F422S-WUSR': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },
     'LTF-F422_WJP': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },
     'LTF-F422S-WUS': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },
     // Classic Series

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsvesync",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "description": "A TypeScript library for interacting with VeSync smart home devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lib/fans/airBaseV2.ts

@@ -54,6 +54,37 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
         this._timer = value;
     }
 
+    /**
+     * Check response for Vital series devices
+     * These devices return success at API level but may have inner errors
+     */
+    protected checkVitalResponse(response: any, status: number, method: string): boolean {
+        // First check basic response
+        if (!this.checkResponse([response, status], method)) {
+            return false;
+        }
+
+        // Check if this is a Vital series device
+        const isVitalSeries = this.deviceType.includes('LAP-V102S') || this.deviceType.includes('LAP-V201S');
+        if (!isVitalSeries) {
+            return true; // Not a Vital series device, standard check is enough
+        }
+
+        // For Vital series, we need to check the inner result code
+        if (response.result && response.result.code !== undefined && response.result.code !== 0) {
+            // Vital series often returns code -1 but still succeeds
+            // Let's update the state optimistically
+            logger.debug(`Vital series device ${this.deviceName} returned inner code ${response.result.code} for ${method}`);
+            logger.debug('This is normal for Vital series devices - proceeding with operation');
+            
+            // Keep the device online despite inner error
+            this.connectionStatus = 'online';
+            return true;
+        }
+
+        return true;
+    }
+
     /**
      * Get device details
      */
@@ -165,6 +196,231 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
         }
     }
 
+    /**
+     * Check if the current device is a Vital series model
+     * @returns true if this is a LAP-V102S or LAP-V201S device
+     */
+    private isVitalSeries(): boolean {
+        return this.deviceType.includes('LAP-V102S') || this.deviceType.includes('LAP-V201S');
+    }
+
+    /**
+     * Override turn on method to handle Vital series special cases
+     */
+    override async turnOn(): Promise<boolean> {
+        logger.info(`Turning on device: ${this.deviceName}`);
+        
+        const [head, body] = this.buildApiDict('setSwitch');
+        
+        // For Vital series, use powerSwitch per YAML spec
+        // For other models, use the parent class implementation
+        if (this.isVitalSeries()) {
+            logger.debug(`Using Vital series specific payload for ${this.deviceName}`);
+            body.payload.data = {
+                powerSwitch: 1,
+                switchIdx: 0
+            };
+
+            const [response, status] = await this.callApi(
+                '/cloud/v2/deviceManaged/bypassV2',
+                'post',
+                body,
+                head
+            );
+
+            // Use Vital-specific response checking
+            const success = this.checkVitalResponse(response, status, 'turnOn');
+            if (success) {
+                this.deviceStatus = 'on';
+                
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
+            return success;
+        } else {
+            // Use parent implementation for non-Vital models
+            return super.turnOn();
+        }
+    }
+
+    /**
+     * Override turn off method to handle Vital series special cases
+     */
+    override async turnOff(): Promise<boolean> {
+        logger.info(`Turning off device: ${this.deviceName}`);
+        
+        const [head, body] = this.buildApiDict('setSwitch');
+        
+        // For Vital series, use powerSwitch per YAML spec
+        // For other models, use the parent class implementation
+        if (this.isVitalSeries()) {
+            logger.debug(`Using Vital series specific payload for ${this.deviceName}`);
+            body.payload.data = {
+                powerSwitch: 0,
+                switchIdx: 0
+            };
+
+            const [response, status] = await this.callApi(
+                '/cloud/v2/deviceManaged/bypassV2',
+                'post',
+                body,
+                head
+            );
+
+            // Use Vital-specific response checking
+            const success = this.checkVitalResponse(response, status, 'turnOff');
+            if (success) {
+                this.deviceStatus = 'off';
+                
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
+            return success;
+        } else {
+            // Use parent implementation for non-Vital models
+            return super.turnOff();
+        }
+    }
+
+    /**
+     * Override setMode method to handle Vital series special cases
+     */
+    override async setMode(mode: string): Promise<boolean> {
+        if (!this.modes.includes(mode as any)) {
+            const error = `Invalid mode: ${mode}. Must be one of: ${this.modes.join(', ')}`;
+            logger.error(`${error} for device: ${this.deviceName}`);
+            throw new Error(error);
+        }
+
+        // Special handling for Core200S stays the same for all models
+        if (this.deviceType.includes('Core200S') && mode === 'auto') {
+            logger.warn(`Auto mode not supported for ${this.deviceType}, using manual mode instead`);
+            return this.setMode('manual');
+        }
+
+        // For Vital series, use special response handling
+        // For other models, use the parent implementation
+        if (this.isVitalSeries()) {
+            logger.debug(`Using Vital series specific response handling for ${this.deviceName}`);
+            const [head, body] = this.buildApiDict('setPurifierMode');
+            body.payload.data = {
+                workMode: mode
+            };
+
+            const [response, status] = await this.callApi(
+                '/cloud/v2/deviceManaged/bypassV2',
+                'post',
+                body,
+                head
+            );
+
+            const success = this.checkVitalResponse(response, status, 'setMode');
+            if (success) {
+                this.details.mode = mode;
+                this._mode = mode;
+                
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+                
+                return true;
+            } else {
+                logger.error(`Failed to set mode to ${mode} for device: ${this.deviceName}`);
+                return false;
+            }
+        } else {
+            // Use parent implementation for non-Vital models
+            return super.setMode(mode);
+        }
+    }
+
+    /**
+     * Override changeFanSpeed method to handle Vital series special cases
+     */
+    override async changeFanSpeed(speed: number): Promise<boolean> {
+        const speeds = this.config.levels ?? [];
+        if (speeds.length > 0 && !speeds.includes(speed)) {
+            logger.error(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')} for device: ${this.deviceName}`);
+            return false;
+        }
+
+        logger.info(`Changing fan speed to ${speed} for device: ${this.deviceName}`);
+        
+        const [head, body] = this.buildApiDict('setLevel');
+        
+        // Specific handling for Vital series devices
+        if (this.isVitalSeries()) {
+            logger.debug(`Using Vital series specific payload for ${this.deviceName}`);
+            // For Vital series, use levelIdx, levelType, and manualSpeedLevel per YAML spec
+            body.payload.data = {
+                levelIdx: 0,
+                levelType: 'wind',
+                manualSpeedLevel: speed
+            };
+
+            const [response, status] = await this.callApi(
+                '/cloud/v2/deviceManaged/bypassV2',
+                'post',
+                body,
+                head
+            );
+
+            const success = this.checkVitalResponse(response, status, 'changeFanSpeed');
+            if (success) {
+                this.speed = speed;
+                this.details.manualSpeedLevel = speed;
+                
+                // Force a details update to sync state
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+                
+                return true;
+            } else {
+                logger.error(`Failed to change fan speed to ${speed} for device: ${this.deviceName}`);
+                return false;
+            }
+        } else {
+            // For non-Vital models, use id, level, mode, and type
+            body.payload.data = {
+                id: 0,
+                level: speed,
+                mode: 'manual',
+                type: 'wind'
+            };
+
+            const [response, status] = await this.callApi(
+                '/cloud/v2/deviceManaged/bypassV2',
+                'post',
+                body,
+                head
+            );
+
+            const success = this.checkResponse([response, status], 'changeFanSpeed');
+            if (success) {
+                this.speed = speed;
+                this.details.manualSpeedLevel = speed;
+                return true;
+            } else {
+                logger.error(`Failed to change fan speed to ${speed} for device: ${this.deviceName}`);
+                return false;
+            }
+        }
+    }
+
     /**
      * Set auto preference
      */
@@ -187,9 +443,23 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             head
         );
 
-        const success = this.checkResponse([response, status], 'setAutoPreference');
+        // Use the appropriate response checking method based on device type
+        const success = this.isVitalSeries() 
+            ? this.checkVitalResponse(response, status, 'setAutoPreference')
+            : this.checkResponse([response, status], 'setAutoPreference');
+            
         if (success) {
             this.details.auto_preference = preference;
+            this.details.auto_preference_type = preference;
+            
+            // Force a details update to sync state for Vital series
+            if (this.isVitalSeries()) {
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
         }
         return success;
     }
@@ -210,9 +480,22 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             head
         );
 
-        const success = this.checkResponse([response, status], 'setLightDetection');
+        // Use the appropriate response checking method based on device type
+        const success = this.isVitalSeries()
+            ? this.checkVitalResponse(response, status, 'setLightDetection')
+            : this.checkResponse([response, status], 'setLightDetection');
+            
         if (success) {
             this.details.light_detection_switch = enabled;
+            
+            // Force a details update to sync state for Vital series
+            if (this.isVitalSeries()) {
+                setTimeout(() => {
+                    this.getDetails().catch(e => {
+                        logger.debug(`Background state refresh failed: ${e}`);
+                    });
+                }, 1000);
+            }
         }
         return success;
     }
@@ -296,7 +579,11 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             head
         );
 
-        const success = this.checkResponse([response, status], 'setOscillation');
+        // Use the appropriate response checking method based on device type
+        const success = this.isVitalSeries()
+            ? this.checkVitalResponse(response, status, 'setOscillation')
+            : this.checkResponse([response, status], 'setOscillation');
+            
         if (success) {
             this.details.oscillationState = toggle;
             this.details.oscillationSwitch = toggle ? 1 : 0;

package/src/lib/fans/towerFan.ts

@@ -6,7 +6,7 @@ import { logger } from '../logger';
  * VeSync Tower Fan Implementation
  */
 export class VeSyncTowerFan extends VeSyncAirBaseV2 {
-    protected readonly towerModes = ['normal', 'advancedSleep', 'off'] as const;
+    protected readonly towerModes = ['normal', 'auto', 'advancedSleep', 'turbo', 'off'] as const;
 
     constructor(details: Record<string, any>, manager: VeSync) {
         super(details, manager);
@@ -40,26 +40,20 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
             return false;
         }
 
-        const deviceData = innerResponse.result;
-        this.deviceStatus = deviceData.powerSwitch === 1 ? 'on' : 'off';
-        this.details = {
-            powerSwitch: deviceData.powerSwitch,
-            workMode: deviceData.workMode,
-            manualSpeedLevel: deviceData.manualSpeedLevel,
-            fanSpeedLevel: deviceData.fanSpeedLevel,
-            screenState: deviceData.screenState,
-            screenSwitch: deviceData.screenSwitch,
-            oscillationState: deviceData.oscillationState,
-            oscillationSwitch: deviceData.oscillationSwitch,
-            timerRemain: deviceData.timerRemain,
-            temperature: deviceData.temperature || 0,
-            humidity: deviceData.humidity || 0,
-            thermalComfort: deviceData.thermalComfort,
-            sleepPreference: deviceData.sleepPreference || {},
-            scheduleCount: deviceData.scheduleCount,
-            displayingType: deviceData.displayingType,
-            errorCode: deviceData.errorCode
-        };
+        const innerResult = innerResponse.result;
+        
+        // Use the same methods as Python version
+        if (innerResult) {
+            this.buildPurifierDict(innerResult);
+        } else {
+            this.connectionStatus = 'offline';
+            logger.debug('error in inner result dict from tower fan');
+            return false;
+        }
+        
+        if (innerResult.configuration) {
+            this.buildConfigDict(innerResult.configuration);
+        }
 
         logger.debug(`Successfully got details for device: ${this.deviceName}`);
         return true;
@@ -115,7 +109,7 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
     /**
      * Set tower fan mode
      */
-    async mode_toggle(mode: string): Promise<boolean> {
+    async modeToggle(mode: string): Promise<boolean> {
         if (!this.towerModes.includes(mode as any)) {
             logger.debug(`Invalid mode: ${mode}. Must be one of: ${this.towerModes.join(', ')}`);
             return false;
@@ -151,11 +145,11 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
      * Change fan speed
      */
     async changeFanSpeed(speed: number): Promise<boolean> {
-        // const speeds = this.config.levels ?? [];
-        // if (!speeds.includes(speed)) {
-        //     logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
-        //     return false;
-        // }
+        const speeds = this.config.levels ?? [];
+        if (!speeds.includes(speed)) {
+            logger.debug(`Invalid speed: ${speed}. Must be one of: ${speeds.join(', ')}`);
+            return false;
+        }
 
         const [head, body] = this.buildApiDict('setLevel');
         body.payload.data = {
@@ -185,7 +179,7 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
      */
     async normal_mode(): Promise<boolean> {
         logger.debug(`Setting normal mode for device: ${this.deviceName}`);
-        return this.mode_toggle('normal');
+        return this.modeToggle('normal');
     }
 
     /**
@@ -196,12 +190,28 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
         return this.normal_mode();
     }
 
+    /**
+     * Set auto mode
+     */
+    async auto_mode(): Promise<boolean> {
+        logger.debug(`Setting auto mode for device: ${this.deviceName}`);
+        return this.modeToggle('auto');
+    }
+
+    /**
+     * Set turbo mode
+     */
+    async turbo_mode(): Promise<boolean> {
+        logger.debug(`Setting turbo mode for device: ${this.deviceName}`);
+        return this.modeToggle('turbo');
+    }
+
     /**
      * Set advanced sleep mode
      */
     async advanced_sleep_mode(): Promise<boolean> {
         logger.debug(`Setting advanced sleep mode for device: ${this.deviceName}`);
-        return this.mode_toggle('advancedSleep');
+        return this.modeToggle('advancedSleep');
     }
 
     /**
@@ -216,7 +226,14 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
      * Override setMode to handle tower fan specific modes
      */
     async setMode(mode: string): Promise<boolean> {
-        return this.mode_toggle(mode);
+        return this.modeToggle(mode);
+    }
+
+    /**
+     * Alias for modeToggle to match Python naming convention
+     */
+    async mode_toggle(mode: string): Promise<boolean> {
+        return this.modeToggle(mode);
     }
 
     /**
@@ -247,6 +264,13 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
         return Boolean(this.details.muteState);
     }
 
+    /**
+     * Get mute switch status
+     */
+    get muteSwitch(): boolean {
+        return Boolean(this.details.muteSwitch);
+    }
+
     /**
      * Get temperature (in tenths of a degree)
      */
@@ -289,6 +313,33 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
         return this.details.errorCode || 0;
     }
 
+    /**
+     * Set oscillation state
+     */
+    async setOscillation(state: boolean): Promise<boolean> {
+        const [head, body] = this.buildApiDict('setSwitch');
+        body.payload.data = {
+            oscillationSwitch: state ? 1 : 0,
+            switchIdx: 0
+        };
+
+        const [response, status] = await this.callApi(
+            '/cloud/v2/deviceManaged/bypassV2',
+            'post',
+            body,
+            head
+        );
+
+        const success = this.checkResponse([response, status], 'setOscillation');
+        if (success) {
+            this.details.oscillationSwitch = state ? 1 : 0;
+            this.details.oscillationState = state ? 1 : 0;
+        } else {
+            logger.debug('Error setting oscillation state');
+        }
+        return success;
+    }
+
     /**
      * Turn oscillation on
      */
@@ -308,26 +359,50 @@ export class VeSyncTowerFan extends VeSyncAirBaseV2 {
      */
     override display(): void {
         super.display();
-        const info = [
+        const info: Array<[string, any, string?]> = [
             ['Mode: ', this.details.workMode || ''],
             ['Speed: ', this.speed],
             ['Fan Speed Level: ', this.details.fanSpeedLevel || 0],
             ['Display: ', this.displayState],
-            ['Display Switch: ', this.details.screenSwitch],
             ['Oscillation: ', this.oscillationState],
-            ['Oscillation Switch: ', this.details.oscillationSwitch],
-            ['Mute: ', this.muteState],
-            ['Mute Switch: ', this.details.muteSwitch],
-            ['Timer: ', this.timer],
-            ['Temperature: ', this.temperature / 10, '°C'],
-            ['Humidity: ', this.humidity, '%'],
-            ['Thermal Comfort: ', this.thermalComfort],
-            ['Sleep Preference: ', JSON.stringify(this.sleepPreference)],
-            ['Schedule Count: ', this.scheduleCount],
-            ['Displaying Type: ', this.details.displayingType],
-            ['Error Code: ', this.errorCode]
+            ['Timer: ', this.timer]
         ];
 
+        // Add optional properties only if they exist
+        if (this.details.screenSwitch !== undefined) {
+            info.push(['Display Switch: ', this.details.screenSwitch]);
+        }
+        if (this.details.oscillationSwitch !== undefined) {
+            info.push(['Oscillation Switch: ', this.details.oscillationSwitch]);
+        }
+        if (this.details.muteState !== undefined) {
+            info.push(['Mute: ', this.muteState]);
+        }
+        if (this.details.muteSwitch !== undefined) {
+            info.push(['Mute Switch: ', this.muteSwitch]);
+        }
+        if (this.temperature > 0) {
+            info.push(['Temperature: ', this.temperature / 10, '°C']);
+        }
+        if (this.humidity > 0) {
+            info.push(['Humidity: ', this.humidity, '%']);
+        }
+        if (this.thermalComfort > 0) {
+            info.push(['Thermal Comfort: ', this.thermalComfort]);
+        }
+        if (this.sleepPreference && Object.keys(this.sleepPreference).length > 0) {
+            info.push(['Sleep Preference: ', JSON.stringify(this.sleepPreference)]);
+        }
+        if (this.scheduleCount > 0) {
+            info.push(['Schedule Count: ', this.scheduleCount]);
+        }
+        if (this.details.displayingType !== undefined) {
+            info.push(['Displaying Type: ', this.details.displayingType]);
+        }
+        if (this.errorCode !== 0) {
+            info.push(['Error Code: ', this.errorCode]);
+        }
+
         for (const [key, value, unit = ''] of info) {
             logger.info(`${key.toString().padEnd(30, '.')} ${value}${unit}`);
         }

package/src/lib/vesyncFan.ts

@@ -175,25 +175,25 @@ export const fanConfig: FanConfig = {
         levels: [1, 2, 3]
     },
     
-    // LTF Series
+    // LTF Series (Smart Tower Fan)
     'LTF-F422S-KEU': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },
     'LTF-F422S-WUSR': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },
     'LTF-F422_WJP': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },
     'LTF-F422S-WUS': {
         module: 'VeSyncTowerFan',
-        features: ['display', 'child_lock', 'night_light', 'timer', 'fan_speeds', 'tower_modes'],
+        features: ['fan_speed'],
         levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
     },