tsvesync 1.0.75 → 1.0.77

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,13 +45,66 @@ 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
      */
     async getDetails() {
+        var _a;
         logger_1.logger.debug(`Getting details for device: ${this.deviceName}`);
         const [head, body] = this.buildApiDict('getPurifierStatus');
         const [response, status] = await this.callApi('/cloud/v2/deviceManaged/bypassV2', 'post', body, head);
+        // Check if this is a Vital series device (LAP-V102S or LAP-V201S)
+        const isVitalSeries = this.deviceType.includes('LAP-V102S') || this.deviceType.includes('LAP-V201S');
+        // First check the outer response
+        if (!response || status !== 200) {
+            logger_1.logger.debug(`Error getting purifier details for ${this.deviceName}: Invalid response`);
+            this.connectionStatus = 'offline';
+            return false;
+        }
+        // For Vital series, we need special handling as they return inner code -1 for details
+        // but still provide valid status information
+        if (isVitalSeries && response.result) {
+            // Check if we have a valid getPurifierStatus response
+            if (response.code === 0 && ((_a = response.result) === null || _a === void 0 ? void 0 : _a.result)) {
+                const statusResponse = response.result.result;
+                // If we have valid status data, use it regardless of inner result code
+                logger_1.logger.debug(`Using status data for Vital series device: ${this.deviceName}`);
+                this.buildPurifierDict(statusResponse);
+                if (statusResponse.configuration) {
+                    this.buildConfigDict(statusResponse.configuration);
+                }
+                // Keep device online since we have valid status
+                this.connectionStatus = 'online';
+                return true;
+            }
+        }
+        // Standard processing for non-Vital devices or when no status data is available
         if (!this.checkResponse([response, status], 'getDetails') || !(response === null || response === void 0 ? void 0 : response.result)) {
             logger_1.logger.debug('Error getting purifier details');
             this.connectionStatus = 'offline';
@@ -116,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
      */
@@ -130,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;
     }
@@ -145,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;
     }
@@ -215,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsvesync",
-  "version": "1.0.75",
+  "version": "1.0.77",
   "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
      */
@@ -68,6 +99,36 @@ export class VeSyncAirBaseV2 extends VeSyncAirBypass {
             head
         );
 
+        // Check if this is a Vital series device (LAP-V102S or LAP-V201S)
+        const isVitalSeries = this.deviceType.includes('LAP-V102S') || this.deviceType.includes('LAP-V201S');
+        
+        // First check the outer response
+        if (!response || status !== 200) {
+            logger.debug(`Error getting purifier details for ${this.deviceName}: Invalid response`);
+            this.connectionStatus = 'offline';
+            return false;
+        }
+
+        // For Vital series, we need special handling as they return inner code -1 for details
+        // but still provide valid status information
+        if (isVitalSeries && response.result) {
+            // Check if we have a valid getPurifierStatus response
+            if (response.code === 0 && response.result?.result) {
+                const statusResponse = response.result.result;
+                
+                // If we have valid status data, use it regardless of inner result code
+                logger.debug(`Using status data for Vital series device: ${this.deviceName}`);
+                this.buildPurifierDict(statusResponse);
+                if (statusResponse.configuration) {
+                    this.buildConfigDict(statusResponse.configuration);
+                }
+                // Keep device online since we have valid status
+                this.connectionStatus = 'online';
+                return true;
+            }
+        }
+        
+        // Standard processing for non-Vital devices or when no status data is available
         if (!this.checkResponse([response, status], 'getDetails') || !response?.result) {
             logger.debug('Error getting purifier details');
             this.connectionStatus = 'offline';
@@ -135,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
      */
@@ -157,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;
     }
@@ -180,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;
     }
@@ -266,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;