@hexar/biometric-identity-sdk-core 1.0.21 → 1.1.1

package/dist/BiometricIdentitySDK.d.ts

@@ -62,6 +62,22 @@ export declare class BiometricIdentitySDK {
         duration?: number;
         instructions?: string[];
     }): Promise<VideoResult>;
+    /**
+     * Validate profile picture with liveness detection
+     * Uses backend AI for validation
+     */
+    validateProfilePicture(params: {
+        sessionId: string;
+        videoFrames: string[];
+        videoDurationMs: number;
+        challengesCompleted?: string[];
+    }): Promise<{
+        isValid: boolean;
+        profilePicture: string;
+        livenessScore: number;
+        faceDetected: boolean;
+        warnings: string[];
+    }>;
     /**
      * Validate identity using all collected data
      * Uses backend AI for validation

package/dist/BiometricIdentitySDK.js

@@ -234,6 +234,58 @@ class BiometricIdentitySDK {
             throw error;
         }
     }
+    /**
+     * Validate profile picture with liveness detection
+     * Uses backend AI for validation
+     */
+    async validateProfilePicture(params) {
+        try {
+            if (!this.isBackendAvailable) {
+                throw this.createError(types_1.BiometricErrorCode.NETWORK_ERROR, 'Backend not available. Cannot perform validation.');
+            }
+            if (!params.videoFrames || params.videoFrames.length === 0) {
+                throw this.createError(types_1.BiometricErrorCode.UNKNOWN_ERROR, 'No video frames provided for validation.');
+            }
+            this.updateState({
+                isLoading: true,
+                currentStep: types_1.SDKStep.VALIDATING,
+                progress: 75
+            });
+            // Reduce number of frames to prevent payload size issues (same as validateIdentity)
+            let videoFrames = params.videoFrames;
+            const MAX_FRAMES = 5; // Reduced to 5 to reduce payload size and processing time
+            if (videoFrames.length > MAX_FRAMES) {
+                const step = Math.floor(videoFrames.length / MAX_FRAMES);
+                videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
+                logger_1.logger.info('Sampled frames for profile picture validation', {
+                    originalCount: params.videoFrames.length,
+                    sampledCount: videoFrames.length
+                });
+            }
+            // Perform backend validation
+            const response = await this.backendClient.validateProfilePicture({
+                sessionId: params.sessionId,
+                videoFrames: videoFrames,
+                videoDurationMs: params.videoDurationMs,
+                challengesCompleted: params.challengesCompleted,
+            });
+            this.updateState({
+                progress: 100,
+                isLoading: false,
+            });
+            return {
+                isValid: response.is_valid,
+                profilePicture: response.profile_picture,
+                livenessScore: response.liveness_score,
+                faceDetected: response.face_detected,
+                warnings: response.warnings || [],
+            };
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
     /**
      * Validate identity using all collected data
      * Uses backend AI for validation

package/dist/api/BackendClient.d.ts

@@ -110,6 +110,21 @@ export interface FullValidationResponse {
     timestamp: string;
     transaction_id: string;
 }
+export interface ProfilePictureValidationResponse {
+    success: boolean;
+    is_valid: boolean;
+    liveness_score: number;
+    profile_picture: string;
+    face_detected: boolean;
+    checks: Array<{
+        name: string;
+        passed: boolean;
+        score: number;
+        details?: string;
+    }>;
+    warnings: string[];
+    session_id?: string;
+}
 export interface BackendClientConfig {
     /** Backend API URL */
     apiEndpoint: string;
@@ -160,6 +175,15 @@ export declare class BackendClient {
         countryCode?: string;
         deviceInfo?: Record<string, any>;
     }): Promise<FullValidationResponse>;
+    /**
+     * Validate profile picture with liveness detection
+     */
+    validateProfilePicture(params: {
+        sessionId: string;
+        videoFrames: string[];
+        videoDurationMs: number;
+        challengesCompleted?: string[];
+    }): Promise<ProfilePictureValidationResponse>;
     /**
      * Convert backend response to SDK ValidationResult format
      */

package/dist/api/BackendClient.js

@@ -116,6 +116,27 @@ class BackendClient {
         });
         return this.request('/api/v1/validate', 'POST', requestBody);
     }
+    /**
+     * Validate profile picture with liveness detection
+     */
+    async validateProfilePicture(params) {
+        if (!this.currentSessionId && params.sessionId) {
+            this.currentSessionId = params.sessionId;
+        }
+        const requestBody = {
+            session_id: this.currentSessionId || params.sessionId,
+            video_frames: params.videoFrames,
+            video_duration_ms: params.videoDurationMs,
+            challenges_completed: params.challengesCompleted || [],
+        };
+        logger_1.logger.info('Profile picture validation request', {
+            hasSessionId: !!this.currentSessionId,
+            sessionId: this.currentSessionId || params.sessionId,
+            videoFramesCount: params.videoFrames.length,
+            videoDurationMs: params.videoDurationMs,
+        });
+        return this.request('/api/v1/profile/validate-face', 'POST', requestBody);
+    }
     /**
      * Convert backend response to SDK ValidationResult format
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexar/biometric-identity-sdk-core",
-  "version": "1.0.21",
+  "version": "1.1.1",
   "description": "Core AI engine for biometric identity verification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/BiometricIdentitySDK.ts

@@ -298,6 +298,81 @@ export class BiometricIdentitySDK {
     }
   }
 
+  /**
+   * Validate profile picture with liveness detection
+   * Uses backend AI for validation
+   */
+  async validateProfilePicture(params: {
+    sessionId: string;
+    videoFrames: string[];
+    videoDurationMs: number;
+    challengesCompleted?: string[];
+  }): Promise<{
+    isValid: boolean;
+    profilePicture: string;
+    livenessScore: number;
+    faceDetected: boolean;
+    warnings: string[];
+  }> {
+    try {
+      if (!this.isBackendAvailable) {
+        throw this.createError(
+          BiometricErrorCode.NETWORK_ERROR,
+          'Backend not available. Cannot perform validation.'
+        );
+      }
+
+      if (!params.videoFrames || params.videoFrames.length === 0) {
+        throw this.createError(
+          BiometricErrorCode.UNKNOWN_ERROR,
+          'No video frames provided for validation.'
+        );
+      }
+
+      this.updateState({ 
+        isLoading: true, 
+        currentStep: SDKStep.VALIDATING,
+        progress: 75 
+      });
+
+      // Reduce number of frames to prevent payload size issues (same as validateIdentity)
+      let videoFrames = params.videoFrames;
+      const MAX_FRAMES = 5; // Reduced to 5 to reduce payload size and processing time
+      if (videoFrames.length > MAX_FRAMES) {
+        const step = Math.floor(videoFrames.length / MAX_FRAMES);
+        videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
+        logger.info('Sampled frames for profile picture validation', {
+          originalCount: params.videoFrames.length,
+          sampledCount: videoFrames.length
+        });
+      }
+
+      // Perform backend validation
+      const response = await this.backendClient.validateProfilePicture({
+        sessionId: params.sessionId,
+        videoFrames: videoFrames,
+        videoDurationMs: params.videoDurationMs,
+        challengesCompleted: params.challengesCompleted,
+      });
+
+      this.updateState({ 
+        progress: 100,
+        isLoading: false,
+      });
+
+      return {
+        isValid: response.is_valid,
+        profilePicture: response.profile_picture,
+        livenessScore: response.liveness_score,
+        faceDetected: response.face_detected,
+        warnings: response.warnings || [],
+      };
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+
   /**
    * Validate identity using all collected data
    * Uses backend AI for validation

package/src/api/BackendClient.ts

@@ -120,6 +120,22 @@ export interface FullValidationResponse {
   transaction_id: string;
 }
 
+export interface ProfilePictureValidationResponse {
+  success: boolean;
+  is_valid: boolean;
+  liveness_score: number;
+  profile_picture: string;
+  face_detected: boolean;
+  checks: Array<{
+    name: string;
+    passed: boolean;
+    score: number;
+    details?: string;
+  }>;
+  warnings: string[];
+  session_id?: string;
+}
+
 export interface BackendClientConfig {
   /** Backend API URL */
   apiEndpoint: string;
@@ -297,6 +313,40 @@ export class BackendClient {
     );
   }
 
+  /**
+   * Validate profile picture with liveness detection
+   */
+  async validateProfilePicture(params: {
+    sessionId: string;
+    videoFrames: string[];
+    videoDurationMs: number;
+    challengesCompleted?: string[];
+  }): Promise<ProfilePictureValidationResponse> {
+    if (!this.currentSessionId && params.sessionId) {
+      this.currentSessionId = params.sessionId;
+    }
+
+    const requestBody = {
+      session_id: this.currentSessionId || params.sessionId,
+      video_frames: params.videoFrames,
+      video_duration_ms: params.videoDurationMs,
+      challenges_completed: params.challengesCompleted || [],
+    };
+
+    logger.info('Profile picture validation request', {
+      hasSessionId: !!this.currentSessionId,
+      sessionId: this.currentSessionId || params.sessionId,
+      videoFramesCount: params.videoFrames.length,
+      videoDurationMs: params.videoDurationMs,
+    });
+
+    return this.request<ProfilePictureValidationResponse>(
+      '/api/v1/profile/validate-face',
+      'POST',
+      requestBody
+    );
+  }
+
   /**
    * Convert backend response to SDK ValidationResult format
    */