valenceai 0.5.1 → 1.0.0

package/src/valenceClient.js

@@ -4,58 +4,88 @@ import FormData from 'form-data';
 import { config } from './config.js';
 import { getHeaders } from './client.js';
 import { log } from './utils/logger.js';
+import { RateLimitAPI } from './rateLimit.js';
+import { StreamingAPI } from './streaming.js';
 
 /**
  * Client for discrete (short) audio processing
  */
 class DiscreteClient {
-  constructor() {}
+  constructor(clientConfig) {
+    this.config = clientConfig;
+  }
 
   /**
    * Get emotions for discrete (short) audio files
-   * @param {string} filePath - Path to the audio file
+   * @param {string} filePath - Path to the audio file (mutually exclusive with audioArray)
+   * @param {Array} audioArray - Audio data as array (mutually exclusive with filePath)
    * @param {string} model - Model type ('4emotions' or '7emotions')
    * @returns {Promise<Object>} Emotion prediction results
-   * @throws {Error} If file doesn't exist, API key missing, or request fails
+   * @throws {Error} If validation fails, API key missing, or request fails
    */
-  async emotions(filePath, model = '4emotions') {
+  async emotions(filePath = null, audioArray = null, model = '4emotions') {
     // Validation
-    if (!filePath || typeof filePath !== 'string') {
-      throw new Error('filePath is required and must be a string');
+    if (filePath && audioArray) {
+      throw new Error('Provide either filePath or audioArray, not both');
+    }
+
+    if (!filePath && !audioArray) {
+      throw new Error('Must provide either filePath or audioArray');
     }
-    
+
     if (!['4emotions', '7emotions'].includes(model)) {
       throw new Error('model must be either "4emotions" or "7emotions"');
     }
-    
-    if (!config.apiKey) {
+
+    if (!this.config.apiKey) {
       throw new Error('VALENCE_API_KEY is required');
     }
-    
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`File not found: ${filePath}`);
-    }
-    
-    log(`Getting emotions for discrete audio: ${filePath} using ${model} model`, 'info');
-    
+
+    const url = `${this.config.baseUrl}/v1/discrete/emotion?model=${model}`;
+
     try {
-      const formData = new FormData();
-      formData.append('file', fs.createReadStream(filePath));
-      const url = `${config.discreteAudioUrl}?model=${model}`;
-      
-      const response = await axios.post(url, formData, {
-        headers: {
-          ...getHeaders(),
-          ...formData.getHeaders()
-        },
-        timeout: 30000 // 30 second timeout
-      });
-      
-      log('Discrete emotion prediction completed successfully', 'info');
-      return response.data;
+      if (filePath) {
+        // File upload method
+        if (!fs.existsSync(filePath)) {
+          throw new Error(`File not found: ${filePath}`);
+        }
+
+        log(`Getting emotions for discrete audio: ${filePath} using ${model} model`, 'info');
+
+        const formData = new FormData();
+        formData.append('file', fs.createReadStream(filePath));
+
+        const response = await axios.post(url, formData, {
+          headers: {
+            'x-api-key': this.config.apiKey,
+            ...formData.getHeaders()
+          },
+          timeout: 30000
+        });
+
+        log('Discrete emotion prediction completed successfully', 'info');
+        return response.data;
+
+      } else {
+        // JSON payload method
+        log(`Getting emotions for audio array using ${model} model`, 'info');
+
+        const payload = { payload: [audioArray] };
+
+        const response = await axios.post(url, payload, {
+          headers: {
+            'x-api-key': this.config.apiKey,
+            'Content-Type': 'application/json'
+          },
+          timeout: 30000
+        });
+
+        log('Discrete emotion prediction completed successfully', 'info');
+        return response.data;
+      }
     } catch (error) {
       log(`Error getting discrete emotions: ${error.message}`, 'error');
-      
+
       if (error.response) {
         throw new Error(`API error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
       } else if (error.request) {
@@ -71,7 +101,8 @@ class DiscreteClient {
  * Client for async (long) audio processing
  */
 class AsyncClient {
-  constructor(partSize = 5 * 1024 * 1024, maxRetries = 3) {
+  constructor(clientConfig, partSize = 5 * 1024 * 1024, maxRetries = 3) {
+    this.config = clientConfig;
     this.partSize = partSize;
     this.maxRetries = maxRetries;
   }
@@ -87,30 +118,30 @@ class AsyncClient {
     if (!filePath || typeof filePath !== 'string') {
       throw new Error('filePath is required and must be a string');
     }
-    
-    if (!config.apiKey) {
+
+    if (!this.config.apiKey) {
       throw new Error('VALENCE_API_KEY is required');
     }
-    
+
     if (!fs.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    
+
     if (this.partSize < 1024 * 1024 || this.partSize > 100 * 1024 * 1024) {
       throw new Error('partSize must be between 1MB and 100MB');
     }
-    
+
     log(`Starting async audio upload for ${filePath}`, 'info');
-    
+
     try {
       const fileSize = fs.statSync(filePath).size;
       const partCount = Math.ceil(fileSize / this.partSize);
-      const initiateUrl = `${config.asyncAudioUrl}/upload/initiate`;
+      const initiateUrl = `${this.config.baseUrl}/v1/asynch/emotion/upload/initiate`;
 
       log(`File size: ${fileSize} bytes, parts: ${partCount}`, 'debug');
 
-      const { data } = await axios.get(initiateUrl, {
-        headers: getHeaders(),
+      const { data } = await axios.post(initiateUrl, null, {
+        headers: { 'x-api-key': this.config.apiKey },
         params: { file_name: filePath.split('/').pop(), part_count: partCount },
         timeout: 30000
       });
@@ -145,13 +176,13 @@ class AsyncClient {
 
       log('All parts uploaded, completing multipart upload', 'info');
 
-      const completeUrl = `${config.asyncAudioUrl}/upload/complete`;
+      const completeUrl = `${this.config.baseUrl}/v1/asynch/emotion/upload/complete`;
       await axios.post(completeUrl, {
         request_id: data.request_id,
         upload_id: data.upload_id,
         parts: parts.sort((a, b) => a.PartNumber - b.PartNumber)
       }, {
-        headers: getHeaders(),
+        headers: { 'x-api-key': this.config.apiKey },
         timeout: 30000
       });
 
@@ -175,7 +206,7 @@ class AsyncClient {
    * @param {string} requestId - Request ID from upload method
    * @param {number} maxAttempts - Maximum polling attempts (default: 20)
    * @param {number} intervalSeconds - Polling interval in seconds (default: 5)
-   * @returns {Promise<Object>} Emotion prediction results
+   * @returns {Promise<Object>} Emotion prediction results with timeline data
    * @throws {Error} If requestId is invalid or prediction times out
    */
   async emotions(requestId, maxAttempts = 20, intervalSeconds = 5) {
@@ -183,53 +214,56 @@ class AsyncClient {
     if (!requestId || typeof requestId !== 'string') {
       throw new Error('requestId is required and must be a string');
     }
-    
-    if (!config.apiKey) {
+
+    if (!this.config.apiKey) {
       throw new Error('VALENCE_API_KEY is required');
     }
-    
+
     if (maxAttempts < 1 || maxAttempts > 100) {
       throw new Error('maxAttempts must be between 1 and 100');
     }
-    
+
     if (intervalSeconds < 1 || intervalSeconds > 60) {
       throw new Error('intervalSeconds must be between 1 and 60');
     }
-    
+
     log(`Starting emotion prediction polling for request ${requestId}`, 'info');
-    
-    const url = `${config.asyncAudioUrl}/prediction`;
+
+    const url = `${this.config.baseUrl}/v1/asynch/emotion/status/${requestId}`;
     const intervalMs = intervalSeconds * 1000;
 
     for (let i = 0; i < maxAttempts; i++) {
       try {
         log(`Polling attempt ${i + 1}/${maxAttempts}`, 'debug');
-        
+
         const res = await axios.get(url, {
-          headers: getHeaders(),
-          params: { request_id: requestId },
+          headers: { 'x-api-key': this.config.apiKey },
           timeout: 15000
         });
 
         if (res.status === 200 && res.data) {
-          log(`Emotions retrieved for request ID: ${requestId}`, 'info');
-          return res.data;
-        }
-        
-        if (res.status === 202) {
-          log('Prediction still processing, waiting...', 'debug');
+          const status = res.data.status;
+
+          if (status === 'completed') {
+            log(`Emotions retrieved for request ID: ${requestId}`, 'info');
+            return res.data;
+          } else if (['processing', 'upload_completed', 'initiated'].includes(status)) {
+            log(`Request ${requestId} status: ${status}, continuing to poll...`, 'debug');
+          } else if (status === 'failed') {
+            throw new Error(`Request ${requestId} failed during processing`);
+          }
         }
-        
+
       } catch (error) {
         if (error.response?.status === 404) {
           throw new Error(`Request ID not found: ${requestId}`);
         } else if (error.response?.status >= 400 && error.response?.status < 500) {
           throw new Error(`Client error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
         }
-        
+
         log(`Polling error (attempt ${i + 1}): ${error.message}`, 'warn');
       }
-      
+
       if (i < maxAttempts - 1) {
         await new Promise(resolve => setTimeout(resolve, intervalMs));
       }
@@ -237,6 +271,54 @@ class AsyncClient {
 
     throw new Error(`Prediction not available after ${maxAttempts} attempts. The request may still be processing.`);
   }
+
+  /**
+   * Get timeline data from completed async emotion prediction
+   * @param {string} requestId - Request ID from upload method
+   * @returns {Promise<Array>} List of emotion predictions with timestamps
+   */
+  async getTimeline(requestId) {
+    const result = await this.emotions(requestId, 1);
+    return result.emotions || [];
+  }
+
+  /**
+   * Get emotion prediction at a specific time
+   * @param {string} requestId - Request ID from upload method
+   * @param {number} timeSeconds - Time in seconds to get emotion for
+   * @returns {Promise<Object|null>} Emotion prediction at specified time, or null if not found
+   */
+  async getEmotionAtTime(requestId, timeSeconds) {
+    const timeline = await this.getTimeline(requestId);
+    for (const emotionData of timeline) {
+      if (emotionData.start_time <= timeSeconds && timeSeconds < emotionData.end_time) {
+        return emotionData;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get the most frequently occurring emotion in the timeline
+   * @param {string} requestId - Request ID from upload method
+   * @returns {Promise<string|null>} The dominant emotion across the timeline
+   */
+  async getDominantEmotion(requestId) {
+    const timeline = await this.getTimeline(requestId);
+    if (!timeline || timeline.length === 0) {
+      return null;
+    }
+
+    const emotionCounts = {};
+    for (const emotionData of timeline) {
+      const emotion = emotionData.emotion;
+      emotionCounts[emotion] = (emotionCounts[emotion] || 0) + 1;
+    }
+
+    return Object.keys(emotionCounts).reduce((a, b) =>
+      emotionCounts[a] > emotionCounts[b] ? a : b
+    );
+  }
 }
 
 /**
@@ -245,12 +327,35 @@ class AsyncClient {
 export class ValenceClient {
   /**
    * Initialize the Valence client
-   * @param {number} partSize - Size of each part in bytes for async uploads (default: 5MB)
-   * @param {number} maxRetries - Maximum retry attempts for async uploads (default: 3)
+   * @param {Object} options - Configuration options
+   * @param {string} options.apiKey - API key for authentication (or set VALENCE_API_KEY env var)
+   * @param {string} options.baseUrl - Base URL for API endpoints (default: https://demo.getvalenceai.com)
+   * @param {string} options.websocketUrl - WebSocket URL for streaming (default: wss://demo.getvalenceai.com)
+   * @param {number} options.partSize - Size of parts for multipart upload (default: 5MB)
+   * @param {number} options.maxRetries - Max retry attempts for uploads (default: 3)
    */
-  constructor(partSize = 5 * 1024 * 1024, maxRetries = 3) {
+  constructor(options = {}) {
+    // Build configuration with priority: parameter > env var > default
+    // Use hasOwnProperty to distinguish between undefined and explicitly set empty values
+    this.config = {
+      apiKey: options.hasOwnProperty('apiKey') ? options.apiKey : config.apiKey,
+      baseUrl: options.hasOwnProperty('baseUrl') ? options.baseUrl : config.baseUrl,
+      websocketUrl: options.hasOwnProperty('websocketUrl') ? options.websocketUrl : config.websocketUrl,
+      logLevel: options.hasOwnProperty('logLevel') ? options.logLevel : config.logLevel
+    };
+
+    // Validate API key
+    if (!this.config.apiKey) {
+      throw new Error('API key not provided and not set in environment (VALENCE_API_KEY)');
+    }
+
+    const partSize = options.partSize || 5 * 1024 * 1024;
+    const maxRetries = options.maxRetries || 3;
+
     // Initialize nested clients
-    this.discrete = new DiscreteClient();
-    this.asynch = new AsyncClient(partSize, maxRetries);
+    this.discrete = new DiscreteClient(this.config);
+    this.asynch = new AsyncClient(this.config, partSize, maxRetries);
+    this.rateLimit = new RateLimitAPI(this.config);
+    this.streaming = new StreamingAPI(this.config);
   }
 }