@eka-care/ekascribe-ts-sdk 1.4.39

package/dist/audio-chunker/vad-web.js

@@ -0,0 +1,389 @@
+import { MicVAD } from '@ricky0123/vad-web';
+import { FRAME_SIZE, LONG_SILENCE_THRESHOLD, OUTPUT_FORMAT, PRE_SPEECH_PAD_FRAMES, SDK_STATUS_CODE, SHORT_SILENCE_THRESHOLD, } from '../constants/constant';
+import EkaScribeStore from '../store/store';
+import { ERROR_CODE } from '../constants/enums';
+class VadWebClient {
+    /**
+     * Class that handle Vad functions and manages audio chunk
+     * @param pref_length Preferred length in seconds
+     * @param desp_length Desperate length in seconds
+     * @param max_length Maximum length in seconds
+     * @param sr Sample rate in Hz
+     */
+    constructor(pref_length, desp_length, max_length, sr) {
+        Object.defineProperty(this, "vad_past", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "last_clip_index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clip_points", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sil_duration_acc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pref_length_samples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "desp_length_samples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "max_length_samples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shor_thsld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "long_thsld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "frame_size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "speech_pad_frames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "micVad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // MicVad Object
+        Object.defineProperty(this, "is_vad_loading", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "noSpeechStartTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "recording_started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lastWarningTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "warningCooldownPeriod", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 2000
+        }); // 2 seconds cooldown after warning
+        this.vad_past = [];
+        this.last_clip_index = 0;
+        this.clip_points = [0];
+        this.sil_duration_acc = 0;
+        this.pref_length_samples = pref_length * sr;
+        this.desp_length_samples = desp_length * sr;
+        this.max_length_samples = max_length * sr;
+        this.shor_thsld = SHORT_SILENCE_THRESHOLD * sr;
+        this.long_thsld = LONG_SILENCE_THRESHOLD * sr;
+        this.frame_size = FRAME_SIZE;
+        this.speech_pad_frames = PRE_SPEECH_PAD_FRAMES;
+        this.micVad = {};
+        // instantiate MicVad
+        // TODO: initialise this in start recording
+        // this.initVad();
+    }
+    /**
+     * Check for continuous silence and trigger periodic warnings
+     * @param isSpeech - vad probability (0 or 1)
+     */
+    checkNoSpeech(isSpeech) {
+        if (!this.recording_started)
+            return;
+        const now = Date.now();
+        const errorCallback = EkaScribeStore.errorCallback;
+        const silenceThreshold = 10000; // 10 seconds
+        if (isSpeech === 0) {
+            if (this.noSpeechStartTime === null) {
+                this.noSpeechStartTime = now;
+            }
+            else {
+                const silenceDuration = now - this.noSpeechStartTime;
+                // Check if we should show a warning (every 10 seconds of silence)
+                if (silenceDuration >= silenceThreshold) {
+                    // Check if enough time has passed since the last warning (cooldown period)
+                    if (this.lastWarningTime === null ||
+                        now - this.lastWarningTime >= this.warningCooldownPeriod) {
+                        if (errorCallback) {
+                            errorCallback({
+                                error_code: ERROR_CODE.NO_AUDIO_CAPTURE,
+                                status_code: SDK_STATUS_CODE.AUDIO_ERROR,
+                                message: 'No audio detected for a while. Please talk or stop the recording if done.',
+                            });
+                        }
+                        this.lastWarningTime = now;
+                        // Reset the silence timer to start counting the next 10 seconds
+                        this.noSpeechStartTime = now;
+                    }
+                }
+            }
+        }
+        else {
+            // Reset timers when speech is detected
+            this.noSpeechStartTime = null;
+            this.lastWarningTime = null;
+            if (errorCallback) {
+                errorCallback({
+                    error_code: ERROR_CODE.SPEECH_DETECTED,
+                    status_code: SDK_STATUS_CODE.SUCCESS,
+                    message: 'Audio captured. Recording continues.',
+                });
+            }
+        }
+    }
+    /**
+     * Get the micVad instance
+     */
+    getMicVad() {
+        return this.micVad;
+    }
+    /**
+     * Check if VAD is loading
+     */
+    isVadLoading() {
+        return this.is_vad_loading;
+    }
+    /**
+     * Process a VAD frame and determine if it's a clip point
+     * @param vad_frame Voice activity detection frame (0 for silence, 1 for speech)
+     */
+    processVadFrame(vad_frame) {
+        let is_clip_point_frame = false;
+        if (this.vad_past.length > 0) {
+            if (vad_frame === 0) {
+                this.sil_duration_acc += 1;
+            }
+            if (vad_frame === 1) {
+                this.sil_duration_acc = 0;
+            }
+        }
+        const sample_passed = this.vad_past.length - this.last_clip_index;
+        if (sample_passed > this.pref_length_samples) {
+            if (this.sil_duration_acc > this.long_thsld) {
+                this.last_clip_index =
+                    this.vad_past.length - Math.min(Math.floor(this.sil_duration_acc / 2), 5);
+                this.clip_points.push(this.last_clip_index);
+                this.sil_duration_acc = 0;
+                is_clip_point_frame = true;
+            }
+        }
+        if (sample_passed > this.desp_length_samples) {
+            if (this.sil_duration_acc > this.shor_thsld) {
+                this.last_clip_index =
+                    this.vad_past.length - Math.min(Math.floor(this.sil_duration_acc / 2), 5);
+                this.clip_points.push(this.last_clip_index);
+                this.sil_duration_acc = 0;
+                is_clip_point_frame = true;
+            }
+        }
+        if (sample_passed >= this.max_length_samples) {
+            this.last_clip_index = this.vad_past.length;
+            this.clip_points.push(this.last_clip_index);
+            this.sil_duration_acc = 0;
+            is_clip_point_frame = true;
+        }
+        this.vad_past.push(vad_frame);
+        if (is_clip_point_frame) {
+            return [true, this.clip_points[this.clip_points.length - 1]];
+        }
+        return [false, this.clip_points[this.clip_points.length - 1]];
+    }
+    /**
+     * initialize the VAD instance
+     */
+    async initVad() {
+        const audioFileManager = EkaScribeStore.audioFileManagerInstance;
+        const audioBuffer = EkaScribeStore.audioBufferInstance;
+        this.is_vad_loading = true;
+        const vad = await MicVAD.new({
+            frameSamples: this.frame_size,
+            preSpeechPadFrames: this.speech_pad_frames,
+            onFrameProcessed: (prob, frames) => {
+                audioFileManager?.incrementTotalRawSamples(frames);
+                audioBuffer?.append(frames);
+                // Check if audio chunk needs to be clipped
+                const { isSpeech } = prob;
+                let vad_dec = 0;
+                if (isSpeech >= 0.5) {
+                    vad_dec = 1;
+                }
+                // Call the new checkNoSpeech function
+                this.checkNoSpeech(vad_dec);
+                const vadResponse = this.processVadFrame(vad_dec);
+                const is_clip_point = vadResponse[0];
+                if (is_clip_point) {
+                    // audio chunk is of float32 Array <ArrayBuffer>
+                    const activeAudioChunk = audioBuffer?.getAudioData();
+                    this.processAudioChunk({ audioFrames: activeAudioChunk });
+                }
+            },
+            onSpeechStart: () => {
+                EkaScribeStore.userSpeechCallback?.(true);
+            },
+            onSpeechEnd: () => {
+                EkaScribeStore.userSpeechCallback?.(false);
+            },
+        });
+        this.is_vad_loading = false;
+        this.micVad = vad;
+        return this.is_vad_loading;
+    }
+    /**
+     * reinitialize the vad instance
+     */
+    async reinitializeVad() {
+        const response = await this.initVad();
+        return response;
+    }
+    /**
+     * process and upload audio chunk to s3
+     */
+    async processAudioChunk({ audioFrames }) {
+        const audioFileManager = EkaScribeStore.audioFileManagerInstance;
+        const audioBuffer = EkaScribeStore.audioBufferInstance;
+        if (!audioFrames || !audioFileManager || !audioBuffer)
+            return;
+        // get the number of chunks already processed
+        const filenumber = (audioFileManager.audioChunks.length || 0) + 1;
+        const fileName = `${filenumber}.${OUTPUT_FORMAT}`;
+        const rawSampleDetails = audioFileManager.getRawSampleDetails();
+        const chunkTimestamps = audioBuffer?.calculateChunkTimestamps(rawSampleDetails.totalRawSamples);
+        try {
+            const chunkInfo = {
+                fileName,
+                timestamp: {
+                    st: chunkTimestamps.start,
+                    et: chunkTimestamps.end,
+                },
+                status: 'pending',
+                audioFrames,
+            };
+            const audioChunkLength = audioFileManager.updateAudioInfo(chunkInfo);
+            audioFileManager?.incrementInsertedSamples(audioBuffer.getCurrentSampleLength(), audioBuffer.getCurrentFrameLength());
+            audioBuffer.resetBufferState();
+            await audioFileManager.uploadAudioToS3({
+                audioFrames,
+                fileName,
+                chunkIndex: audioChunkLength - 1,
+            });
+        }
+        catch (error) {
+            console.error('Error uploading audio chunk:', error);
+        }
+    }
+    /**
+     * Start VAD
+     */
+    startVad() {
+        this.micVad.start();
+        this.recording_started = true;
+        // this.monitorAudioCapture();
+    }
+    /**
+     * Pause VAD
+     */
+    pauseVad() {
+        this.micVad.pause();
+        this.recording_started = false;
+    }
+    /**
+     * reset vadWeb instance
+     */
+    resetVadWebInstance() {
+        this.vad_past = [];
+        this.last_clip_index = 0;
+        this.clip_points = [0];
+        this.sil_duration_acc = 0;
+        this.noSpeechStartTime = null;
+        this.lastWarningTime = null;
+        this.recording_started = false;
+        // TODO: will handle this - dont pass this callback - handle it properly - clear the error callback on client side on resetEkascribe
+        if (EkaScribeStore.errorCallback) {
+            EkaScribeStore.errorCallback({
+                error_code: ERROR_CODE.SPEECH_DETECTED,
+                status_code: SDK_STATUS_CODE.SUCCESS,
+                message: 'Audio captured. Recording continues.',
+            });
+        }
+    }
+    /**
+     * monitor initial audio capture within starting 4 seconds
+     */
+    monitorAudioCapture() {
+        const audioBuffer = EkaScribeStore.audioBufferInstance;
+        const errorCallback = EkaScribeStore.errorCallback;
+        setTimeout(() => {
+            if (audioBuffer && audioBuffer.getCurrentSampleLength() <= 0) {
+                this.micVad.pause();
+                if (errorCallback) {
+                    errorCallback({
+                        error_code: ERROR_CODE.NO_AUDIO_CAPTURE,
+                        status_code: SDK_STATUS_CODE.AUDIO_ERROR,
+                        message: 'No audio is being captured. Please check your microphone.',
+                    });
+                }
+                return false;
+            }
+            return true;
+        }, 5000);
+    }
+    /**
+     * Callback to configure constants
+     */
+    configureVadConstants({ pref_length, desp_length, max_length, sr, frame_size, pre_speech_pad_frames, short_thsld, long_thsld, }) {
+        this.pref_length_samples = pref_length * sr;
+        this.desp_length_samples = desp_length * sr;
+        this.max_length_samples = max_length * sr;
+        this.shor_thsld = short_thsld * sr;
+        this.long_thsld = long_thsld * sr;
+        this.frame_size = frame_size;
+        this.speech_pad_frames = pre_speech_pad_frames;
+    }
+}
+export default VadWebClient;

package/dist/aws-services/configure-aws.d.ts

@@ -0,0 +1,5 @@
+export declare function configureAWS({ accessKeyId, secretKey, sessionToken, }: {
+    accessKeyId: string;
+    secretKey: string;
+    sessionToken: string;
+}): void;

package/dist/aws-services/configure-aws.js

@@ -0,0 +1,13 @@
+import * as AWS from 'aws-sdk';
+export function configureAWS({ accessKeyId, secretKey, sessionToken, }) {
+    try {
+        AWS.config.update({
+            sessionToken,
+            accessKeyId,
+            secretAccessKey: secretKey,
+        });
+    }
+    catch (err) {
+        console.log(err, 'AWS config error');
+    }
+}

package/dist/aws-services/get-files-s3.d.ts

@@ -0,0 +1,10 @@
+import * as AWS from 'aws-sdk';
+type TS3Response = {
+    response?: AWS.S3.GetObjectOutput;
+    error?: string;
+};
+export declare const getFilesS3: ({ fileName, maxPollingTime, }: {
+    fileName: string;
+    maxPollingTime: number;
+}) => Promise<TS3Response>;
+export {};

package/dist/aws-services/get-files-s3.js

@@ -0,0 +1,30 @@
+import * as AWS from 'aws-sdk';
+import s3RetryWrapper from './s3-retry-wrapper';
+export const getFilesS3 = async ({ fileName, maxPollingTime, }) => {
+    try {
+        const requestBody = {
+            Bucket: 'm-prod-voice2rx',
+            Key: fileName,
+        };
+        const getFileCall = () => new Promise((resolve, reject) => {
+            const s3Bucket = new AWS.S3({
+                region: 'ap-south-1',
+                maxRetries: 0,
+            });
+            s3Bucket.getObject(requestBody, (err, data) => {
+                if (err)
+                    return reject(err);
+                resolve(data);
+            });
+        });
+        // retry upload with s3RetryWrapper
+        const result = await s3RetryWrapper(getFileCall, maxPollingTime, 1000, 0);
+        return {
+            response: result,
+        };
+    }
+    catch (error) {
+        console.error('getFilesS3 =>', error);
+        throw error;
+    }
+};

package/dist/aws-services/s3-retry-wrapper.d.ts

@@ -0,0 +1,2 @@
+declare function s3RetryWrapper<T>(s3Fn: () => Promise<T>, maxRetryCount: number, delay: number, retryAttempt: number, is_shared_worker?: boolean): Promise<T>;
+export default s3RetryWrapper;

package/dist/aws-services/s3-retry-wrapper.js

@@ -0,0 +1,38 @@
+import postCogInit from '../api/post-cog-init';
+import { configureAWS } from './configure-aws';
+async function s3RetryWrapper(s3Fn, maxRetryCount, delay, retryAttempt, is_shared_worker = false) {
+    try {
+        return await s3Fn();
+    }
+    catch (error) {
+        if (retryAttempt >= maxRetryCount) {
+            throw error;
+        }
+        if (is_shared_worker) {
+            // eslint-disable-next-line
+            // @ts-ignore
+            if (error.statusCode >= 400) {
+                throw error;
+            }
+        }
+        else {
+            // eslint-disable-next-line
+            // @ts-ignore
+            if (error.code === 'ExpiredToken') {
+                const cogResponse = await postCogInit();
+                const { credentials } = cogResponse;
+                if (credentials) {
+                    configureAWS({
+                        accessKeyId: credentials.AccessKeyId,
+                        secretKey: credentials.SecretKey,
+                        sessionToken: credentials.SessionToken,
+                    });
+                }
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        // Retry the operation
+        return s3RetryWrapper(s3Fn, maxRetryCount, delay, retryAttempt + 1);
+    }
+}
+export default s3RetryWrapper;

package/dist/aws-services/translate-text-to-target-language.d.ts

@@ -0,0 +1,6 @@
+declare function awsTranslateText({ source_language, target_language, content, }: {
+    source_language: string;
+    target_language: string;
+    content: string;
+}): Promise<void>;
+export default awsTranslateText;

package/dist/aws-services/translate-text-to-target-language.js

@@ -0,0 +1,18 @@
+import { TranslateClient, TranslateTextCommand } from '@aws-sdk/client-translate';
+const translateClient = new TranslateClient({ region: 'ap-south-1' }); // e.g., "us-east-1"
+async function awsTranslateText({ source_language, target_language, content, }) {
+    const command = new TranslateTextCommand({
+        SourceLanguageCode: source_language,
+        TargetLanguageCode: target_language,
+        Text: content,
+    });
+    try {
+        const result = await translateClient.send(command);
+        console.log(result, 'result');
+        console.log('Translated text:', result.TranslatedText);
+    }
+    catch (error) {
+        console.error('Translation error:', error);
+    }
+}
+export default awsTranslateText;

package/dist/aws-services/upload-file-to-s3.d.ts

@@ -0,0 +1,13 @@
+declare const pushFileToS3: ({ fileBlob, fileName, txnID, businessID, is_shared_worker, }: {
+    fileBlob: Blob;
+    fileName: string;
+    txnID: string;
+    businessID: string;
+    is_shared_worker?: boolean;
+}) => Promise<{
+    success?: string;
+    error?: string;
+    errorCode?: string;
+    code?: number;
+}>;
+export default pushFileToS3;

package/dist/aws-services/upload-file-to-s3.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+import * as AWS from 'aws-sdk';
+import s3RetryWrapper from './s3-retry-wrapper';
+import { S3_BUCKET_NAME } from '../constants/constant';
+const pushFileToS3 = async ({ fileBlob, fileName, txnID, businessID, is_shared_worker = false, }) => {
+    try {
+        const requestBody = {
+            Bucket: S3_BUCKET_NAME,
+            Key: fileName,
+            Body: fileBlob,
+            Metadata: {
+                txnid: txnID,
+                bid: businessID,
+            },
+        };
+        const uploadCall = () => new Promise((resolve, reject) => {
+            const s3Bucket = new AWS.S3({
+                region: 'ap-south-1',
+                maxRetries: 0,
+            });
+            s3Bucket.upload(requestBody, (err, data) => {
+                if (err)
+                    return reject(err);
+                resolve(data);
+            });
+        });
+        // retry upload with s3RetryWrapper
+        const result = await s3RetryWrapper(uploadCall, 3, 2000, 0, is_shared_worker);
+        // Return success with the data
+        return { success: result.ETag || 'Upload successful' };
+    }
+    catch (error) {
+        const err = JSON.stringify(error, null, 2);
+        console.error('pushFilesToS3V2 error =>', err);
+        if (error.statusCode && error.statusCode >= 400) {
+            return {
+                error: `Expired token. Please re-authenticate! ${err}`,
+                errorCode: 'ExpiredToken',
+                code: error.statusCode,
+            };
+        }
+        return {
+            error: `Something went wrong! ${err}`,
+            code: error.statusCode,
+        };
+    }
+};
+export default pushFileToS3;

package/dist/constants/constant.d.ts

@@ -0,0 +1,27 @@
+export declare const PREF_CHUNK_LENGTH = 10;
+export declare const DESP_CHUNK_LENGTH = 20;
+export declare const MAX_CHUNK_LENGTH = 25;
+export declare const FRAME_SIZE = 1024;
+export declare const SAMPLING_RATE = 16000;
+export declare const DURATION_PER_FRAME: number;
+export declare const SILENCE_THRESHOLD = 0.01;
+export declare const FRAME_RATE: number;
+export declare const SHORT_SILENCE_THRESHOLD = 0.1;
+export declare const LONG_SILENCE_THRESHOLD = 0.5;
+export declare const SPEECH_DETECTION_THRESHOLD = 0.5;
+export declare const PRE_SPEECH_PAD_FRAMES = 20;
+export declare const BITRATE = 128;
+export declare const QUALITY = 0;
+export declare const CHANNELS = 1;
+export declare const AUDIO_BUFFER_SIZE_IN_S: number;
+export declare const OUTPUT_FORMAT = "mp3";
+export declare const AUDIO_EXTENSION_TYPE_MAP: Record<string, string>;
+export declare const S3_BUCKET_NAME = "m-prod-voice-record";
+export declare const SDK_STATUS_CODE: {
+    AUDIO_ERROR: number;
+    SUCCESS: number;
+    TXN_ERROR: number;
+    BAD_REQUEST: number;
+    INTERNAL_SERVER_ERROR: number;
+    FORBIDDEN: number;
+};

package/dist/constants/constant.js

@@ -0,0 +1,33 @@
+export const PREF_CHUNK_LENGTH = 10;
+export const DESP_CHUNK_LENGTH = 20;
+export const MAX_CHUNK_LENGTH = 25;
+export const FRAME_SIZE = 1024;
+export const SAMPLING_RATE = 16000;
+export const DURATION_PER_FRAME = FRAME_SIZE / SAMPLING_RATE;
+export const SILENCE_THRESHOLD = 0.01;
+export const FRAME_RATE = SAMPLING_RATE / FRAME_SIZE;
+export const SHORT_SILENCE_THRESHOLD = 0.1;
+export const LONG_SILENCE_THRESHOLD = 0.5;
+export const SPEECH_DETECTION_THRESHOLD = 0.5;
+// export const REDEMPTION_FRAMES = 10;
+export const PRE_SPEECH_PAD_FRAMES = 20;
+// export const MIN_SPEECH_FRAMES = 80;
+export const BITRATE = 128;
+export const QUALITY = 0;
+export const CHANNELS = 1;
+export const AUDIO_BUFFER_SIZE_IN_S = DESP_CHUNK_LENGTH + 5;
+export const OUTPUT_FORMAT = 'mp3';
+export const AUDIO_EXTENSION_TYPE_MAP = {
+    m4a: 'audio/m4a',
+    wav: 'audio/wav',
+    mp3: 'audio/mpeg',
+};
+export const S3_BUCKET_NAME = 'm-prod-voice-record';
+export const SDK_STATUS_CODE = {
+    AUDIO_ERROR: 1001,
+    SUCCESS: 200,
+    TXN_ERROR: 1003,
+    BAD_REQUEST: 1004,
+    INTERNAL_SERVER_ERROR: 1005,
+    FORBIDDEN: 1006,
+};