@eka-care/ekascribe-ts-sdk 1.5.12 → 1.5.14

package/dist/audio-chunker/audio-file-manager.d.ts

@@ -1,4 +1,4 @@
-import { TAudioChunksInfo, TFileUploadProgressCallback } from '../constants/types';
+import { TAudioChunksInfo } from '../constants/types';
 type TUploadAudioChunkParams = {
     audioFrames: Float32Array;
     fileName: string;
@@ -14,7 +14,6 @@ declare class AudioFileManager {
     audioChunks: TAudioChunksInfo[];
     private uploadPromises;
     private successfulUploads;
-    private onProgressCallback?;
     private totalRawSamples;
     private totalRawFrames;
     private totalInsertedSamples;
@@ -42,10 +41,6 @@ declare class AudioFileManager {
         totalInsertedSamples: number;
         totalInsertedFrames: number;
     };
-    /**
-     * Set callback for upload progress updates
-     */
-    setProgressCallback(callback: TFileUploadProgressCallback): void;
     /**
      * Update audio information array, this will update the audio chunks info
      * (+ the latest chunk , affects the length of chunks data struct)

package/dist/audio-chunker/audio-file-manager.js

@@ -2,8 +2,9 @@ import { AUDIO_EXTENSION_TYPE_MAP, OUTPUT_FORMAT } from '../constants/constant';
 import pushFileToS3 from '../aws-services/upload-file-to-s3';
 import postCogInit from '../api/post-cog-init';
 import { configureAWS } from '../aws-services/configure-aws';
-import { SHARED_WORKER_ACTION } from '../constants/enums';
+import { CALLBACK_TYPE, SHARED_WORKER_ACTION } from '../constants/enums';
 import compressAudioToMp3 from '../utils/compress-mp3-audio';
+import EkaScribeStore from '../store/store';
 class AudioFileManager {
     initialiseClassInstance() {
         this.audioChunks = [];
@@ -49,12 +50,6 @@ class AudioFileManager {
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "onProgressCallback", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "totalRawSamples", {
             enumerable: true,
             configurable: true,
@@ -127,12 +122,6 @@ class AudioFileManager {
             totalInsertedFrames: this.totalInsertedFrames,
         };
     }
-    /**
-     * Set callback for upload progress updates
-     */
-    setProgressCallback(callback) {
-        this.onProgressCallback = callback;
-    }
     /**
      * Update audio information array, this will update the audio chunks info
      * (+ the latest chunk , affects the length of chunks data struct)
@@ -146,26 +135,46 @@ class AudioFileManager {
             // new URL(relativeOrAbsolutePath, baseUrl)
             const worker = new SharedWorker(new URL('../shared-worker/s3-file-upload.js', import.meta.url));
             this.sharedWorkerInstance = worker;
+            const onEventCallback = EkaScribeStore.eventCallback;
             this.sharedWorkerInstance.port.onmessage = async (event) => {
                 const workerResponse = event.data;
                 switch (workerResponse.action) {
                     case SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS: {
-                        // Callback
+                        if (onEventCallback) {
+                            onEventCallback({
+                                callback_type: CALLBACK_TYPE.AWS_CONFIGURE_STATUS,
+                                status: 'success',
+                                message: workerResponse.message,
+                                timestamp: new Date().toISOString(),
+                            });
+                        }
                         return;
                     }
                     case SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR: {
-                        // Callback
+                        if (onEventCallback) {
+                            onEventCallback({
+                                callback_type: CALLBACK_TYPE.AWS_CONFIGURE_STATUS,
+                                status: 'error',
+                                message: workerResponse.message,
+                                timestamp: new Date().toISOString(),
+                            });
+                        }
                         return;
                     }
                     case SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS: {
-                        // Callback
                         const { fileCount: fileName, chunkIndex, fileBlob, compressedAudioBuffer, } = workerResponse.requestBody;
-                        if (this.onProgressCallback && compressedAudioBuffer) {
-                            this.onProgressCallback({
-                                success: this.successfulUploads.length,
-                                total: this.audioChunks.length,
-                                fileName,
-                                chunkData: compressedAudioBuffer,
+                        if (onEventCallback && compressedAudioBuffer) {
+                            onEventCallback({
+                                callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                status: 'info',
+                                message: 'Audioframes of chunk to store in IDB',
+                                timestamp: new Date().toISOString(),
+                                data: {
+                                    success: this.successfulUploads.length,
+                                    total: this.audioChunks.length,
+                                    fileName,
+                                    chunkData: compressedAudioBuffer,
+                                },
                             });
                         }
                         if (workerResponse.response.success) {
@@ -180,24 +189,35 @@ class AudioFileManager {
                                     response: workerResponse.response.success,
                                 };
                             }
-                            if (this.onProgressCallback) {
-                                this.onProgressCallback({
-                                    success: this.successfulUploads.length,
-                                    total: this.audioChunks.length,
-                                    is_uploaded: true,
+                            if (onEventCallback) {
+                                onEventCallback({
+                                    callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                    status: 'success',
+                                    message: workerResponse.response.success,
+                                    timestamp: new Date().toISOString(),
+                                    data: {
+                                        success: this.successfulUploads.length,
+                                        total: this.audioChunks.length,
+                                        is_uploaded: true,
+                                    },
                                 });
                             }
                         }
                         else {
-                            if (this.onProgressCallback) {
-                                this.onProgressCallback({
-                                    success: this.successfulUploads.length,
-                                    total: this.audioChunks.length,
-                                    fileName,
-                                    is_uploaded: false,
+                            if (onEventCallback) {
+                                onEventCallback({
+                                    callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                    status: 'error',
+                                    message: workerResponse.response.error || 'Upload failed',
+                                    timestamp: new Date().toISOString(),
                                     error: {
                                         code: workerResponse.response.code,
-                                        msg: 'Tokens expired.',
+                                        msg: workerResponse.response.error,
+                                        details: workerResponse.response.errorCode,
+                                    },
+                                    data: {
+                                        fileName,
+                                        is_uploaded: false,
                                     },
                                 });
                             }
@@ -273,12 +293,19 @@ class AudioFileManager {
         const audioBlob = new Blob(compressedAudioBuffer, {
             type: AUDIO_EXTENSION_TYPE_MAP[OUTPUT_FORMAT],
         });
-        if (this.onProgressCallback) {
-            this.onProgressCallback({
-                success: this.successfulUploads.length,
-                total: this.audioChunks.length,
-                fileName,
-                chunkData: compressedAudioBuffer,
+        const onEventCallback = EkaScribeStore.eventCallback;
+        if (onEventCallback) {
+            onEventCallback({
+                callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                status: 'info',
+                message: 'Audio chunks count to display success/total file count and to store chunks in IDB',
+                timestamp: new Date().toISOString(),
+                data: {
+                    success: this.successfulUploads.length,
+                    total: this.audioChunks.length,
+                    fileName,
+                    chunkData: compressedAudioBuffer,
+                },
             });
         }
         // Push upload promise to track status
@@ -302,11 +329,17 @@ class AudioFileManager {
                         response: response.success,
                     };
                 }
-                if (this.onProgressCallback) {
-                    this.onProgressCallback({
-                        success: this.successfulUploads.length,
-                        total: this.audioChunks.length,
-                        is_uploaded: true,
+                if (onEventCallback) {
+                    onEventCallback({
+                        callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                        status: 'success',
+                        message: response.success,
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            success: this.successfulUploads.length,
+                            total: this.audioChunks.length,
+                            is_uploaded: true,
+                        },
                     });
                 }
             }
@@ -320,15 +353,20 @@ class AudioFileManager {
                         response: response.error || 'Upload failed',
                     };
                 }
-                if (this.onProgressCallback) {
-                    this.onProgressCallback({
-                        success: this.successfulUploads.length,
-                        total: this.audioChunks.length,
-                        fileName,
-                        is_uploaded: false,
+                if (onEventCallback) {
+                    onEventCallback({
+                        callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                        status: 'error',
+                        message: response.error || 'Upload failed',
+                        timestamp: new Date().toISOString(),
                         error: {
                             code: response.code || 500,
-                            msg: 'Tokens expired.',
+                            msg: response.error || 'Upload failed',
+                            details: response.errorCode,
+                        },
+                        data: {
+                            fileName,
+                            is_uploaded: false,
                         },
                     });
                 }
@@ -346,10 +384,17 @@ class AudioFileManager {
      */
     async uploadAudioChunkInWorker({ audioFrames, fileName, chunkIndex, }) {
         const s3FileName = `${this.filePath}/${fileName}`;
-        if (this.onProgressCallback) {
-            this.onProgressCallback({
-                success: this.successfulUploads.length,
-                total: this.audioChunks.length,
+        const onEventCallback = EkaScribeStore.eventCallback;
+        if (onEventCallback) {
+            onEventCallback({
+                callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                status: 'info',
+                message: 'Audio chunks count to display success/total file count',
+                timestamp: new Date().toISOString(),
+                data: {
+                    success: this.successfulUploads.length,
+                    total: this.audioChunks.length,
+                },
             });
         }
         this.sharedWorkerInstance?.port.postMessage({
@@ -495,6 +540,7 @@ class AudioFileManager {
         if (failedFiles.length === 0) {
             return [];
         }
+        const onEventCallback = EkaScribeStore.eventCallback;
         if (this.sharedWorkerInstance) {
             this.audioChunks.forEach((chunk, index) => {
                 const { fileName, fileBlob, status, audioFrames } = chunk;
@@ -517,10 +563,16 @@ class AudioFileManager {
         }
         else {
             this.uploadPromises = []; // Reset upload promises for retries
-            if (this.onProgressCallback) {
-                this.onProgressCallback({
-                    success: this.successfulUploads.length,
-                    total: this.audioChunks.length,
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                    status: 'info',
+                    message: 'Audio chunks count to display success/total file count',
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        success: this.successfulUploads.length,
+                        total: this.audioChunks.length,
+                    },
                 });
             }
             this.audioChunks.forEach((chunk, index) => {
@@ -547,10 +599,16 @@ class AudioFileManager {
                         }).then((response) => {
                             if (response.success) {
                                 this.successfulUploads.push(fileName);
-                                if (this.onProgressCallback) {
-                                    this.onProgressCallback({
-                                        success: this.successfulUploads.length,
-                                        total: this.audioChunks.length,
+                                if (onEventCallback) {
+                                    onEventCallback({
+                                        callback_type: CALLBACK_TYPE.FILE_UPLOAD_STATUS,
+                                        status: 'info',
+                                        message: 'Audio chunks count to display success/total file count',
+                                        timestamp: new Date().toISOString(),
+                                        data: {
+                                            success: this.successfulUploads.length,
+                                            total: this.audioChunks.length,
+                                        },
                                     });
                                 }
                                 this.audioChunks[index] = {
@@ -593,7 +651,6 @@ class AudioFileManager {
         this.filePath = '';
         this.businessID = '';
         this.isAWSConfigured = false;
-        this.onProgressCallback = undefined;
     }
 }
 export default AudioFileManager;

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

@@ -1,7 +1,7 @@
 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';
+import { CALLBACK_TYPE, ERROR_CODE } from '../constants/enums';
 class VadWebClient {
     /**
      * Class that handle Vad functions and manages audio chunk
@@ -134,7 +134,7 @@ class VadWebClient {
         if (!this.recording_started)
             return;
         const now = Date.now();
-        const errorCallback = EkaScribeStore.errorCallback;
+        const onEventCallback = EkaScribeStore.eventCallback;
         const silenceThreshold = 10000; // 10 seconds
         if (isSpeech === 0) {
             if (this.noSpeechStartTime === null) {
@@ -147,11 +147,16 @@ class VadWebClient {
                     // 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,
-                                error_message: 'No audio detected for a while. Please talk or stop the recording if done.',
+                        if (onEventCallback) {
+                            onEventCallback({
+                                callback_type: CALLBACK_TYPE.VAD_AUDIO_STATUS,
+                                status: 'info',
+                                message: 'No audio detected for a while. Please talk or stop the recording if done.',
+                                timestamp: new Date().toISOString(),
+                                data: {
+                                    error_code: ERROR_CODE.NO_AUDIO_CAPTURE,
+                                    status_code: SDK_STATUS_CODE.AUDIO_ERROR,
+                                },
                             });
                         }
                         this.lastWarningTime = now;
@@ -165,11 +170,16 @@ class VadWebClient {
             // 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,
-                    success_message: 'Audio captured. Recording continues.',
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: CALLBACK_TYPE.VAD_AUDIO_STATUS,
+                    status: 'info',
+                    message: 'Audio captured. Recording continues.',
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        error_code: ERROR_CODE.SPEECH_DETECTED,
+                        status_code: SDK_STATUS_CODE.SUCCESS,
+                    },
                 });
             }
         }
@@ -361,28 +371,26 @@ class VadWebClient {
         this.recording_started = false;
         this.is_vad_loading = true; // Reset to initial state
         // this.micVad = {} as MicVAD; // Clear the instance
-        if (EkaScribeStore.errorCallback) {
-            EkaScribeStore.errorCallback({
-                error_code: ERROR_CODE.SPEECH_DETECTED,
-                status_code: SDK_STATUS_CODE.SUCCESS,
-                success_message: 'Audio captured. Recording continues.',
-            });
-        }
     }
     /**
      * monitor initial audio capture within starting 4 seconds
      */
     monitorAudioCapture() {
         const audioBuffer = EkaScribeStore.audioBufferInstance;
-        const errorCallback = EkaScribeStore.errorCallback;
+        const onEventCallback = EkaScribeStore.eventCallback;
         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,
-                        error_message: 'No audio is being captured. Please check your microphone.',
+                if (onEventCallback) {
+                    onEventCallback({
+                        callback_type: CALLBACK_TYPE.VAD_AUDIO_STATUS,
+                        status: 'info',
+                        message: 'No audio is being captured. Please check your microphone.',
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            error_code: ERROR_CODE.NO_AUDIO_CAPTURE,
+                            status_code: SDK_STATUS_CODE.AUDIO_ERROR,
+                        },
                     });
                 }
                 return false;

package/dist/constants/enums.d.ts

@@ -48,3 +48,13 @@ export declare enum SHARED_WORKER_ACTION {
     WAIT_FOR_ALL_UPLOADS_SUCCESS = "wait_for_all_uploads_success",
     WAIT_FOR_ALL_UPLOADS_ERROR = "wait_for_all_uploads_error"
 }
+export declare enum CALLBACK_TYPE {
+    AWS_CONFIGURE_STATUS = "aws_configure_status",
+    FILE_UPLOAD_STATUS = "file_upload_status",
+    TRANSACTION_STATUS = "transaction_status",
+    TEMPLATE_OPERATION_STATUS = "template_operation_status",
+    AUTHENTICATION_STATUS = "authentication_status",
+    NETWORK_STATUS = "network_status",
+    STORAGE_STATUS = "storage_status",
+    VAD_AUDIO_STATUS = "vad_audio_status"
+}

package/dist/constants/enums.js

@@ -53,3 +53,14 @@ export var SHARED_WORKER_ACTION;
     SHARED_WORKER_ACTION["WAIT_FOR_ALL_UPLOADS_SUCCESS"] = "wait_for_all_uploads_success";
     SHARED_WORKER_ACTION["WAIT_FOR_ALL_UPLOADS_ERROR"] = "wait_for_all_uploads_error";
 })(SHARED_WORKER_ACTION || (SHARED_WORKER_ACTION = {}));
+export var CALLBACK_TYPE;
+(function (CALLBACK_TYPE) {
+    CALLBACK_TYPE["AWS_CONFIGURE_STATUS"] = "aws_configure_status";
+    CALLBACK_TYPE["FILE_UPLOAD_STATUS"] = "file_upload_status";
+    CALLBACK_TYPE["TRANSACTION_STATUS"] = "transaction_status";
+    CALLBACK_TYPE["TEMPLATE_OPERATION_STATUS"] = "template_operation_status";
+    CALLBACK_TYPE["AUTHENTICATION_STATUS"] = "authentication_status";
+    CALLBACK_TYPE["NETWORK_STATUS"] = "network_status";
+    CALLBACK_TYPE["STORAGE_STATUS"] = "storage_status";
+    CALLBACK_TYPE["VAD_AUDIO_STATUS"] = "vad_audio_status";
+})(CALLBACK_TYPE || (CALLBACK_TYPE = {}));

package/dist/constants/types.d.ts

@@ -1,4 +1,4 @@
-import { ERROR_CODE } from './enums';
+import { ERROR_CODE, CALLBACK_TYPE } from './enums';
 export type TGetConfigV2Response = {
     data?: {
         supported_languages: TGetConfigItem[];
@@ -244,17 +244,33 @@ export type TSessionStatus = {
         };
     };
 };
-export type TFileUploadProgressCallback = (args: {
-    success: number;
-    total: number;
-    is_uploaded?: boolean;
-    fileName?: string;
-    chunkData?: Uint8Array<ArrayBufferLike>[];
+export type TEventCallback = (args: {
+    callback_type: CALLBACK_TYPE;
+    status: 'success' | 'error' | 'progress' | 'info';
+    message: string;
     error?: {
         code: number;
         msg: string;
+        details?: unknown;
     };
+    data?: TFileUploadCallbackData | TTransactionCallbackData;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
 }) => void;
+export type TFileUploadCallbackData = {
+    success?: number;
+    total?: number;
+    is_uploaded?: boolean;
+    fileName?: string;
+    chunkData?: Uint8Array<ArrayBufferLike>[];
+};
+export type TTransactionCallbackData = {
+    txn_id?: string;
+    request?: unknown;
+    response?: unknown;
+    status_code?: number;
+    error_code?: ERROR_CODE;
+};
 export interface TPostV1TemplateRequest {
     title: string;
     desc?: string;

package/dist/fetch-client/index.js

@@ -1,10 +1,9 @@
 import { GET_CLIENT_ID, GET_AUTH_TOKEN } from './helper';
 import EkaScribeStore from '../store/store';
-import { ERROR_CODE } from '../constants/enums';
-import { SDK_STATUS_CODE } from '../constants/constant';
+import { CALLBACK_TYPE } from '../constants/enums';
 const API_TIMEOUT_MS = 10000;
 export default async function fetchWrapper(url, options = {}, timeoutMs = API_TIMEOUT_MS) {
-    const errorCallback = EkaScribeStore.errorCallback;
+    const onEventCallback = EkaScribeStore.eventCallback;
     const controller = new AbortController();
     let timeoutId = null;
     try {
@@ -25,24 +24,32 @@ export default async function fetchWrapper(url, options = {}, timeoutMs = API_TI
             signal: controller.signal,
             credentials: 'include',
         });
-        if (errorCallback) {
-            errorCallback({
-                error_code: ERROR_CODE.FETCH_WRAPPER_RESPONSE,
-                status_code: response.status,
-                success_message: 'Fetch wrapper response: ' + JSON.stringify(response),
-                request: 'Request body: ' + JSON.stringify(options.body),
+        if (onEventCallback) {
+            onEventCallback({
+                callback_type: CALLBACK_TYPE.AUTHENTICATION_STATUS,
+                status: 'success',
+                message: 'Fetch wrapper response: ' + response.status,
+                timestamp: new Date().toISOString(),
+                data: {
+                    request: 'Request body: ' + JSON.stringify(options.body),
+                    response: 'Response body: ' + JSON.stringify(response),
+                },
             });
         }
         return response;
     }
     catch (error) {
         console.error(error, 'error in fetch wrapper - SDK');
-        if (errorCallback) {
-            errorCallback({
-                error_code: ERROR_CODE.FETCH_WRAPPER_ERROR,
-                status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
-                error_message: 'Fetch wrapper response: ' + JSON.stringify(error),
-                request: 'Request body: ' + JSON.stringify(options.body),
+        if (onEventCallback) {
+            onEventCallback({
+                callback_type: CALLBACK_TYPE.AUTHENTICATION_STATUS,
+                status: 'error',
+                message: 'Fetch wrapper response: ' + error,
+                timestamp: new Date().toISOString(),
+                data: {
+                    request: 'Request body: ' + JSON.stringify(options.body),
+                    response: 'Error body: ' + JSON.stringify(error),
+                },
             });
         }
         throw error;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { TGetStatusResponse } from './api/transaction/get-voice-api-v3-status';
-import { TEndRecordingResponse, TErrorCallback, TFileUploadProgressCallback, TGetTransactionHistoryResponse, TPatchTransactionRequest, TPatchVoiceApiV2ConfigRequest, TPatchVoiceApiV3StatusRequest, TPostTransactionResponse, TPostV1ConvertToTemplateRequest, TPostV1TemplateRequest, TPostV1TemplateSectionRequest, TPostV1UploadAudioFilesRequest, TStartRecordingRequest } from './constants/types';
+import { TEndRecordingResponse, TEventCallback, TGetTransactionHistoryResponse, TPatchTransactionRequest, TPatchVoiceApiV2ConfigRequest, TPatchVoiceApiV3StatusRequest, TPostTransactionResponse, TPostV1ConvertToTemplateRequest, TPostV1TemplateRequest, TPostV1TemplateSectionRequest, TPostV1UploadAudioFilesRequest, TStartRecordingRequest } from './constants/types';
 import { TSearchSessionsByPatientRequest } from './utils/search-sessions-by-patient-name';
 declare class EkaScribe {
     private static instance;
@@ -41,9 +41,8 @@ declare class EkaScribe {
     getFailedFiles(): string[];
     getTotalAudioFiles(): import("./constants/types").TAudioChunksInfo[];
     resetEkaScribe(): void;
-    onError(callback: TErrorCallback): void;
     onUserSpeechCallback(callback: (isSpeech: boolean) => void): void;
-    onFileUploadProgressCallback(callback: TFileUploadProgressCallback): void;
+    onEventCallback(callback: TEventCallback): void;
     configureVadConstants({ pref_length, desp_length, max_length, sr, frame_size, pre_speech_pad_frames, short_thsld, long_thsld, }: {
         pref_length: number;
         desp_length: number;

package/dist/index.js

@@ -7,7 +7,7 @@ import AudioBufferManager from './audio-chunker/audio-buffer-manager';
 import AudioFileManager from './audio-chunker/audio-file-manager';
 import VadWebClient from './audio-chunker/vad-web';
 import { AUDIO_BUFFER_SIZE_IN_S, DESP_CHUNK_LENGTH, FRAME_RATE, MAX_CHUNK_LENGTH, PREF_CHUNK_LENGTH, SAMPLING_RATE, SDK_STATUS_CODE, } from './constants/constant';
-import { ERROR_CODE } from './constants/enums';
+import { CALLBACK_TYPE, ERROR_CODE } from './constants/enums';
 import setEnv from './fetch-client/helper';
 import endVoiceRecording from './main/end-recording';
 import pauseVoiceRecording from './main/pause-recording';
@@ -126,12 +126,21 @@ class EkaScribe {
     }
     async patchSessionStatus({ sessionId, processing_status, processing_error, }) {
         try {
+            const onEventCallback = EkaScribeStore.eventCallback;
             this.vadInstance.pauseVad();
             const patchTransactionResponse = await patchTransactionStatus({
                 sessionId,
                 processing_status,
                 processing_error,
             });
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: CALLBACK_TYPE.TRANSACTION_STATUS,
+                    status: 'info',
+                    message: `Transaction cancel status: ${patchTransactionResponse.code}`,
+                    timestamp: new Date().toISOString(),
+                });
+            }
             this.resetEkaScribe();
             return patchTransactionResponse;
         }
@@ -145,6 +154,7 @@ class EkaScribe {
     async commitTransactionCall() {
         try {
             const txnID = EkaScribeStore.txnID;
+            const onEventCallback = EkaScribeStore.eventCallback;
             let txnCommitMsg = '';
             if (EkaScribeStore.sessionStatus[txnID].api?.status === 'stop' ||
                 EkaScribeStore.sessionStatus[txnID].api?.status === 'commit') {
@@ -155,6 +165,17 @@ class EkaScribe {
                     txnId: EkaScribeStore.txnID,
                 });
                 txnCommitMsg = message;
+                if (onEventCallback) {
+                    onEventCallback({
+                        callback_type: CALLBACK_TYPE.TRANSACTION_STATUS,
+                        status: 'info',
+                        message: `Transaction commit status: ${txnCommitStatusCode}`,
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            request: audioFiles,
+                        },
+                    });
+                }
                 if (txnCommitStatusCode != 200) {
                     return {
                         error_code: ERROR_CODE.TXN_COMMIT_FAILED,
@@ -242,14 +263,12 @@ class EkaScribe {
         EkaScribeStore.resetStore();
         console.log(this.audioFileManagerInstance, this.audioBufferInstance, this.vadInstance, EkaScribeStore, 'after reset ekascribe');
     }
-    onError(callback) {
-        EkaScribeStore.errorCallback = callback;
-    }
     onUserSpeechCallback(callback) {
         EkaScribeStore.userSpeechCallback = callback;
     }
-    onFileUploadProgressCallback(callback) {
-        this.audioFileManagerInstance.setProgressCallback(callback);
+    onEventCallback(callback) {
+        EkaScribeStore.eventCallback = callback;
+        // this.audioFileManagerInstance.setProgressCallback(callback);
     }
     configureVadConstants({ pref_length, desp_length, max_length, sr, frame_size, pre_speech_pad_frames, short_thsld, long_thsld, }) {
         return this.vadInstance.configureVadConstants({

package/dist/main/end-recording.js

@@ -1,7 +1,7 @@
 import postTransactionCommit from '../api/transaction/post-transaction-commit';
 import postTransactionStop from '../api/transaction/post-transaction-stop';
 import { OUTPUT_FORMAT, SDK_STATUS_CODE } from '../constants/constant';
-import { ERROR_CODE } from '../constants/enums';
+import { CALLBACK_TYPE, ERROR_CODE } from '../constants/enums';
 import EkaScribeStore from '../store/store';
 const endVoiceRecording = async () => {
     try {
@@ -9,6 +9,7 @@ const endVoiceRecording = async () => {
         const fileManagerInstance = EkaScribeStore.audioFileManagerInstance;
         const vadInstance = EkaScribeStore.vadInstance;
         const txnID = EkaScribeStore.txnID;
+        const onEventCallback = EkaScribeStore.eventCallback;
         if (!fileManagerInstance || !audioBufferInstance || !vadInstance) {
             throw new Error('Class instances are not initialized');
         }
@@ -54,6 +55,17 @@ const endVoiceRecording = async () => {
                 audioFiles,
                 txnId: txnID,
             });
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: CALLBACK_TYPE.TRANSACTION_STATUS,
+                    status: 'info',
+                    message: `Transaction stop status: ${txnStopStatusCode}`,
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        request: audioFiles,
+                    },
+                });
+            }
             if (txnStopStatusCode != 200) {
                 return {
                     error_code: ERROR_CODE.TXN_STOP_FAILED,
@@ -101,6 +113,17 @@ const endVoiceRecording = async () => {
                 txnId: txnID,
                 audioFiles,
             });
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: CALLBACK_TYPE.TRANSACTION_STATUS,
+                    status: 'info',
+                    message: `Transaction commit status: ${txnCommitStatusCode}`,
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        request: audioFiles,
+                    },
+                });
+            }
             if (txnCommitStatusCode != 200) {
                 return {
                     error_code: ERROR_CODE.TXN_COMMIT_FAILED,

package/dist/main/init-transaction.js

@@ -1,12 +1,13 @@
 import postTransactionInit from '../api/transaction/post-transaction-init';
 import { S3_BUCKET_NAME, SDK_STATUS_CODE } from '../constants/constant';
-import { ERROR_CODE } from '../constants/enums';
+import { CALLBACK_TYPE, ERROR_CODE } from '../constants/enums';
 import EkaScribeStore from '../store/store';
 const initialiseTransaction = async (request) => {
     try {
         const { txn_id } = request;
         const fileManagerInstance = EkaScribeStore.audioFileManagerInstance;
         const sessionStatus = EkaScribeStore.sessionStatus;
+        const onEventCallback = EkaScribeStore.eventCallback;
         let businessID = '';
         let userOID = '';
         let userUUID = '';
@@ -28,6 +29,14 @@ const initialiseTransaction = async (request) => {
                 s3Url: `s3://${S3_BUCKET_NAME}/${filePath}`,
             });
             const { code: txnInitStatusCode, b_id: businessId, oid, uuid, message: txnInitMessage, error: txnInitError, } = txnInitResponse;
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: CALLBACK_TYPE.TRANSACTION_STATUS,
+                    status: 'info',
+                    message: `Transaction init status: ${txnInitStatusCode}`,
+                    timestamp: new Date().toISOString(),
+                });
+            }
             if (txnInitStatusCode === 400 && txnInitError?.code === ERROR_CODE.TXN_LIMIT_EXCEEDED) {
                 return {
                     error_code: ERROR_CODE.TXN_LIMIT_EXCEEDED,

package/dist/main/retry-upload-recording.js

@@ -1,10 +1,11 @@
 import postTransactionCommit from '../api/transaction/post-transaction-commit';
 import { SDK_STATUS_CODE } from '../constants/constant';
-import { ERROR_CODE } from '../constants/enums';
+import { CALLBACK_TYPE, ERROR_CODE } from '../constants/enums';
 import EkaScribeStore from '../store/store';
 const retryUploadFailedFiles = async ({ force_commit, }) => {
     try {
         const fileManagerInstance = EkaScribeStore.audioFileManagerInstance;
+        const onEventCallback = EkaScribeStore.eventCallback;
         if (!fileManagerInstance) {
             throw new Error('Class instances are not initialized');
         }
@@ -28,6 +29,17 @@ const retryUploadFailedFiles = async ({ force_commit, }) => {
                 txnId: EkaScribeStore.txnID,
                 audioFiles,
             });
+            if (onEventCallback) {
+                onEventCallback({
+                    callback_type: CALLBACK_TYPE.TRANSACTION_STATUS,
+                    status: 'info',
+                    message: `Transaction commit status: ${txnCommitStatusCode}`,
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        request: audioFiles,
+                    },
+                });
+            }
             if (txnCommitStatusCode != 200) {
                 return {
                     error_code: ERROR_CODE.TXN_COMMIT_FAILED,

package/dist/store/store.d.ts

@@ -1,7 +1,7 @@
 import AudioBufferManager from '../audio-chunker/audio-buffer-manager';
 import AudioFileManager from '../audio-chunker/audio-file-manager';
 import VadWebClient from '../audio-chunker/vad-web';
-import { TErrorCallback, TSessionStatus } from '../constants/types';
+import { TEventCallback, TSessionStatus } from '../constants/types';
 declare class EkaScribeStore {
     private static instance;
     private _txnID;
@@ -10,8 +10,8 @@ declare class EkaScribeStore {
     private _audioFileManagerInstance;
     private _audioBufferInstance;
     private _sessionStatus;
-    private _errorCallback;
     private _userSpeechCallback;
+    private _eventCallback;
     static getInstance(): EkaScribeStore;
     get vadInstance(): VadWebClient | null;
     set vadInstance(value: VadWebClient);
@@ -25,10 +25,10 @@ declare class EkaScribeStore {
     set sessionBucketPath(value: string);
     get sessionStatus(): TSessionStatus;
     set sessionStatus(value: TSessionStatus);
-    get errorCallback(): TErrorCallback | null;
-    set errorCallback(callback: TErrorCallback | null);
     get userSpeechCallback(): ((isSpeech: boolean) => void) | null;
     set userSpeechCallback(callback: ((isSpeech: boolean) => void) | null);
+    get eventCallback(): TEventCallback | null;
+    set eventCallback(callback: TEventCallback | null);
     resetStore(): void;
 }
 declare const _default: EkaScribeStore;

package/dist/store/store.js

@@ -36,13 +36,13 @@ class EkaScribeStore {
             writable: true,
             value: {}
         });
-        Object.defineProperty(this, "_errorCallback", {
+        Object.defineProperty(this, "_userSpeechCallback", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: null
         });
-        Object.defineProperty(this, "_userSpeechCallback", {
+        Object.defineProperty(this, "_eventCallback", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -97,13 +97,6 @@ class EkaScribeStore {
     set sessionStatus(value) {
         this._sessionStatus = value;
     }
-    // Error Callback
-    get errorCallback() {
-        return this._errorCallback;
-    }
-    set errorCallback(callback) {
-        this._errorCallback = callback;
-    }
     // User Speech Callback
     get userSpeechCallback() {
         return this._userSpeechCallback;
@@ -111,14 +104,21 @@ class EkaScribeStore {
     set userSpeechCallback(callback) {
         this._userSpeechCallback = callback;
     }
+    // Event Callback
+    get eventCallback() {
+        return this._eventCallback;
+    }
+    set eventCallback(callback) {
+        this._eventCallback = callback;
+    }
     // Reset store to initial state
     resetStore() {
         this._txnID = '';
         this._sessionBucketPath = '';
         this._sessionStatus = {};
         // Clear callbacks
-        this._errorCallback = null;
         this._userSpeechCallback = null;
+        this._eventCallback = null;
     }
 }
 export default EkaScribeStore.getInstance();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eka-care/ekascribe-ts-sdk",
-  "version": "1.5.12",
+  "version": "1.5.14",
   "main": "dist/index.js",
   "repository": "git@github.com:eka-care/eka-js-sdk.git",
   "author": "Sanikagoyal28 <sanikagoyal9@gmail.com>",