@eka-care/ekascribe-ts-sdk 2.0.13 → 2.0.14

package/README.md

@@ -1047,53 +1047,129 @@ Use this method to completely destroy the VAD instance and free up resources.
 ekaScribe.destroyVad();
 ```
 
+### 8. Update Authentication Tokens
+
+Use this method to update the access token when it expires (e.g., when you receive a 401 error).
+
+```ts
+ekascribe.updateAuthTokens({ access_token: 'new_access_token' });
+```
+
+**When to use:**
+
+- When any API method returns `status_code: 401`
+- When `eventCallback` returns `error.code: 401` in `file_upload_status`
+- Before token expiration to prevent upload failures
+
 ## Generic Callbacks
 
 ### 1. Event callback
 
-This is a comprehensive callback that provides information about SDK operations, including success events, errors, progress updates, and system status. Use this callback to monitor all SDK activities and handle events globally in your application.
-
-```ts
-ekaScribe.onEventCallback((eventData) => {
-  console.log('Event callback triggered:', eventData);
+This callback provides information about SDK operations. Use it to monitor file uploads, transaction status, AWS configuration, and authentication errors.
+
+```ts
+ekascribe.onEventCallback((eventData) => {
+  console.log('Event callback:', eventData);
+
+  // Handle different callback types
+  switch (eventData.callback_type) {
+    case 'file_upload_status':
+      // Track audio chunk upload progress
+      console.log(`Uploaded ${eventData.data?.success}/${eventData.data?.total} chunks`);
+      break;
+    case 'transaction_status':
+      // Monitor transaction lifecycle (init, stop, commit, cancel)
+      console.log('Transaction update:', eventData.message);
+      break;
+    case 'aws_configure_status':
+      // AWS S3 configuration status
+      console.log('AWS config:', eventData.status);
+      break;
+    case 'authentication_status':
+      // API authentication errors
+      console.error('Auth error:', eventData.message);
+      break;
+  }
 });
 ```
 
-- #### Sample Callback Data:
+- #### Callback Structure:
 
 ```ts
 {
-  callback_type: 'AUDIO_UPLOAD' | 'TRANSACTION_STATUS' | 'VAD_STATUS' | 'RECORDING_STATUS',
-  status: 'success' | 'error' | 'progress' | 'info',
-  message: 'Audio file uploaded successfully',
+  callback_type: 'file_upload_status' | 'transaction_status' | 'aws_configure_status' | 'authentication_status',
+  status: 'success' | 'error' | 'info',
+  message: string,
+  timestamp: string, // ISO timestamp
   error?: {
-    code: 500,
-    msg: 'Upload failed',
-    details: { fileName: 'audio_chunk_1.mp3' }
+    code: number,
+    msg: string,
+    details: any
   },
   data?: {
-    success: 3,
-    total: 4,
-    is_uploaded: true,
-    fileName: 'audio_chunk_1.mp3',
-    request: { txn_id: 'abc-123' },
-    response: { status: 'uploaded' }
-  },
-  timestamp: '2024-01-15T10:30:45.123Z',
-  metadata?: {
-    txn_id: 'abc-123',
-    chunk_index: 1
+    success?: number,      // Number of successfully uploaded chunks
+    total?: number,        // Total number of chunks
+    is_uploaded?: boolean, // Whether current chunk uploaded successfully
+    fileName?: string,     // Current file name
+    chunkData?: Uint8Array[], // Audio chunk data for current audiofile
+    request?: any,         // API request details
+    response?: any         // API response details
   }
 }
 ```
 
+- #### Callback Types Explained:
+
+**`file_upload_status`** - Track audio chunk upload progress
+
+Use this to monitor upload progress of audio chunks:
+
+- `status: 'info'` - Audio chunk info
+
+  - `data.success`: Count of successfully uploaded chunks
+  - `data.total`: Total chunks generated
+  - `data.fileName`: Current chunk file name
+  - `data.chunkData`: Audio data for current chunk
+
+- `status: 'success'` - Chunk uploaded successfully
+
+  - `data.success`: Updated successful upload count
+  - `data.total`: Total chunks
+  - `data.is_uploaded`: true
+
+- `status: 'error'` - Chunk upload failed
+
+  - `error.code`: HTTP error code
+  - `error.msg`: Error message
+  - `error.details`: Additional error details
+
+- Status codes to handle:
+
+  If `error.code === 401`, it means your access token has expired. Update tokens immediately:
+
+  ```ts
+  ekascribe.onEventCallback((eventData) => {
+    if (eventData.callback_type === 'file_upload_status' && eventData.status === 'error') {
+      if (eventData.error?.code === 401) {
+        // Token expired - update it
+        sdkConfig.access_token = '<new_access_token>';
+        ekascribe.updateAuthTokens({ access_token: sdkConfig.access_token });
+      }
+    }
+  });
+  ```
+
 ### 2. User speech callback
 
-This callback will return a boolean indicating whether the user is speaking or not.
+Triggered by Voice Activity Detection (VAD) when user starts or stops speaking.
 
 ```ts
-ekaScribe.onUserSpeechCallback((isSpeech) => {
-  console.log(isSpeech ? 'User is speaking' : 'User is not speaking');
+ekascribe.onUserSpeechCallback((isSpeech) => {
+  if (isSpeech) {
+    console.log('User started speaking');
+  } else {
+    console.log('User stopped speaking');
+  }
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eka-care/ekascribe-ts-sdk",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "EkaScribe TypeScript SDK - Modern ES2020 build",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",