@eka-care/ekascribe-ts-sdk 1.5.11 → 1.5.13

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,44 @@ 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: {
+                                    fileName,
+                                    chunkData: compressedAudioBuffer,
+                                },
                             });
                         }
                         if (workerResponse.response.success) {
@@ -180,24 +187,31 @@ 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,
                                     },
                                 });
                             }
@@ -273,12 +287,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 +323,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 +347,16 @@ 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,
                         },
                     });
                 }
@@ -346,10 +374,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 +530,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 +553,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 +589,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 +641,6 @@ class AudioFileManager {
         this.filePath = '';
         this.businessID = '';
         this.isAWSConfigured = false;
-        this.onProgressCallback = undefined;
     }
 }
 export default AudioFileManager;

package/dist/constants/enums.d.ts

@@ -48,3 +48,12 @@ 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"
+}

package/dist/constants/enums.js

@@ -53,3 +53,13 @@ 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 || (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,31 @@ 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;
+};
 export interface TPostV1TemplateRequest {
     title: string;
     desc?: string;

package/dist/fetch-client/helper.js

@@ -1,10 +1,10 @@
 const DEV = {
-    COG_HOST: 'https://cog.dev.eka.care',
-    EKA_VOICE_HOST_V1: 'https://v2rxbe.dev.eka.care/voice/api/v1',
-    EKA_VOICE_HOST_V2: 'https://v2rxbe.dev.eka.care/voice/api/v2',
-    EKA_VOICE_HOST_V3: 'https://v2rxbe.dev.eka.care/voice/api/v3',
-    COOK_V1: ' https://deepthought-genai.dev.eka.care/api/v1',
-    EKA_HOST: 'https://api.dev.eka.care',
+    COG_HOST: 'https://app.dev.ekascribe.ai/',
+    EKA_VOICE_HOST_V1: 'https://app.dev.ekascribe.ai/voice/api/v1',
+    EKA_VOICE_HOST_V2: 'https://app.dev.ekascribe.ai/voice/api/v2',
+    EKA_VOICE_HOST_V3: 'https://app.dev.ekascribe.ai/voice/api/v3',
+    COOK_V1: ' https://app.dev.ekascribe.ai/api/v1',
+    EKA_HOST: 'https://app.dev.ekascribe.ai',
 };
 const PROD = {
     COG_HOST: 'https://cog.eka.care',

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, TErrorCallback, 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;
@@ -43,7 +43,7 @@ declare class EkaScribe {
     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,
@@ -248,8 +269,9 @@ class EkaScribe {
     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 { TErrorCallback, TEventCallback, TSessionStatus } from '../constants/types';
 declare class EkaScribeStore {
     private static instance;
     private _txnID;
@@ -12,6 +12,7 @@ declare class EkaScribeStore {
     private _sessionStatus;
     private _errorCallback;
     private _userSpeechCallback;
+    private _eventCallback;
     static getInstance(): EkaScribeStore;
     get vadInstance(): VadWebClient | null;
     set vadInstance(value: VadWebClient);
@@ -29,6 +30,8 @@ declare class EkaScribeStore {
     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

@@ -48,6 +48,12 @@ class EkaScribeStore {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "_eventCallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
     }
     static getInstance() {
         if (!EkaScribeStore.instance) {
@@ -111,6 +117,13 @@ 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 = '';
@@ -119,6 +132,7 @@ class EkaScribeStore {
         // 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.11",
+  "version": "1.5.13",
   "main": "dist/index.js",
   "repository": "git@github.com:eka-care/eka-js-sdk.git",
   "author": "Sanikagoyal28 <sanikagoyal9@gmail.com>",