valenceai 0.5.0 → 1.0.0

package/tests/asyncAudio.test.js

@@ -10,11 +10,11 @@ describe('AsyncAudio', () => {
   beforeEach(() => {
     process.env = { ...originalEnv };
     process.env.VALENCE_API_KEY = 'test-api-key';
-    process.env.VALENCE_ASYNCH_URL = 'https://test-api.com';
-    
+    process.env.VALENCE_API_BASE_URL = 'https://test-api.com';
+
     fsMock = jest.spyOn(fs, 'existsSync');
     statMock = jest.spyOn(fs, 'statSync');
-    
+
     // Mock createReadStream to simulate file chunks
     jest.spyOn(fs, 'createReadStream').mockReturnValue({
       [Symbol.asyncIterator]: async function* () {
@@ -44,9 +44,9 @@ describe('AsyncAudio', () => {
         ]
       };
 
-      // Mock initiate request
+      // Mock initiate request (v1 endpoint)
       nock('https://test-api.com')
-        .get('/upload/initiate')
+        .get('/v1/asynch/emotion/upload/initiate')
         .query({ file_name: 'test.wav', part_count: 2 })
         .reply(200, mockInitiateResponse);
 
@@ -59,9 +59,9 @@ describe('AsyncAudio', () => {
         .put('/part2')
         .reply(200, '', { etag: '"etag2"' });
 
-      // Mock complete request
+      // Mock complete request (v1 endpoint)
       nock('https://test-api.com')
-        .post('/upload/complete', {
+        .post('/v1/asynch/emotion/upload/complete', {
           request_id: 'req-123',
           upload_id: 'upload-123',
           parts: [
@@ -71,21 +71,21 @@ describe('AsyncAudio', () => {
         })
         .reply(200);
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       const result = await client.asynch.upload('test.wav');
-      
+
       expect(result).toBe('req-123');
     });
 
     test('should throw error when filePath is missing', async () => {
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-key' });
       await expect(client.asynch.upload()).rejects.toThrow(
         'filePath is required and must be a string'
       );
     });
 
     test('should throw error when filePath is not a string', async () => {
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-key' });
       await expect(client.asynch.upload(123)).rejects.toThrow(
         'filePath is required and must be a string'
       );
@@ -93,11 +93,10 @@ describe('AsyncAudio', () => {
 
     test('should throw error when API key is missing', async () => {
       delete process.env.VALENCE_API_KEY;
-      
-      const client = new ValenceClient();
-      await expect(client.asynch.upload('test.wav')).rejects.toThrow(
-        'VALENCE_API_KEY is required'
-      );
+
+      expect(() => {
+        new ValenceClient();
+      }).toThrow('API key not provided');
     });
 
     test('should throw error when file does not exist', async () => {
@@ -180,83 +179,88 @@ describe('AsyncAudio', () => {
   });
 
   describe('getEmotions', () => {
-    test('should successfully get emotions', async () => {
+    test('should successfully get emotions with timeline data', async () => {
       const mockResponse = {
-        emotions: {
-          happy: 0.7,
-          sad: 0.2,
-          angry: 0.1
-        }
+        emotions: [
+          {
+            timestamp: 0.5,
+            start_time: 0.0,
+            end_time: 1.0,
+            emotion: 'happy',
+            confidence: 0.9,
+            all_predictions: { happy: 0.9, sad: 0.1 }
+          },
+          {
+            timestamp: 1.5,
+            start_time: 1.0,
+            end_time: 2.0,
+            emotion: 'sad',
+            confidence: 0.8,
+            all_predictions: { happy: 0.2, sad: 0.8 }
+          }
+        ],
+        status: 'completed'
       };
 
+      // v1 endpoint with request_id in path
       nock('https://test-api.com')
-        .get('/prediction')
-        .query({ request_id: 'req-123' })
+        .get('/v1/asynch/emotion/status/req-123')
         .reply(200, mockResponse);
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       const result = await client.asynch.emotions('req-123');
-      
+
       expect(result).toEqual(mockResponse);
+      expect(result.emotions.length).toBe(2);
+      expect(result.emotions[0].emotion).toBe('happy');
     });
 
     test('should poll until success', async () => {
-      const mockResponse = { emotions: { happy: 1.0 } };
+      const mockResponse = { emotions: [], status: 'completed' };
 
       nock('https://test-api.com')
-        .get('/prediction')
-        .query({ request_id: 'req-123' })
+        .get('/v1/asynch/emotion/status/req-123')
         .reply(202) // Processing
-        .get('/prediction')
-        .query({ request_id: 'req-123' })
+        .get('/v1/asynch/emotion/status/req-123')
         .reply(200, mockResponse); // Success
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       const result = await client.asynch.emotions('req-123', 5, 100); // Short interval for testing
-      
+
       expect(result).toEqual(mockResponse);
     });
 
     test('should throw error when requestId is missing', async () => {
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-key' });
       await expect(client.asynch.emotions()).rejects.toThrow(
         'requestId is required and must be a string'
       );
     });
 
     test('should throw error when requestId is not a string', async () => {
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-key' });
       await expect(client.asynch.emotions(123)).rejects.toThrow(
         'requestId is required and must be a string'
       );
     });
 
-    test('should throw error when API key is missing', async () => {
-      delete process.env.VALENCE_API_KEY;
-      
-      const client = new ValenceClient();
-      await expect(client.asynch.emotions('req-123')).rejects.toThrow(
-        'VALENCE_API_KEY is required'
-      );
-    });
-
     test('should throw error with invalid maxTries', async () => {
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-key' });
       await expect(client.asynch.emotions('req-123', 0)).rejects.toThrow(
         'maxTries must be between 1 and 100'
       );
-      
+
       await expect(client.asynch.emotions('req-123', 101)).rejects.toThrow(
         'maxTries must be between 1 and 100'
       );
     });
 
     test('should throw error with invalid intervalMs', async () => {
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-key' });
       await expect(client.asynch.emotions('req-123', 5, 500)).rejects.toThrow(
         'intervalMs must be between 1000 and 60000'
       );
-      
+
       await expect(client.asynch.emotions('req-123', 5, 70000)).rejects.toThrow(
         'intervalMs must be between 1000 and 60000'
       );
@@ -264,11 +268,10 @@ describe('AsyncAudio', () => {
 
     test('should handle 404 errors', async () => {
       nock('https://test-api.com')
-        .get('/prediction')
-        .query({ request_id: 'invalid-id' })
+        .get('/v1/asynch/emotion/status/invalid-id')
         .reply(404);
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       await expect(client.asynch.emotions('invalid-id')).rejects.toThrow(
         'Request ID not found: invalid-id'
       );
@@ -276,11 +279,10 @@ describe('AsyncAudio', () => {
 
     test('should handle client errors', async () => {
       nock('https://test-api.com')
-        .get('/prediction')
-        .query({ request_id: 'req-123' })
+        .get('/v1/asynch/emotion/status/req-123')
         .reply(400, { message: 'Bad request' });
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       await expect(client.asynch.emotions('req-123')).rejects.toThrow(
         'Client error (400): Bad request'
       );
@@ -288,12 +290,11 @@ describe('AsyncAudio', () => {
 
     test('should timeout after max attempts', async () => {
       nock('https://test-api.com')
-        .get('/prediction')
-        .query({ request_id: 'req-123' })
+        .get('/v1/asynch/emotion/status/req-123')
         .times(3)
         .reply(202); // Always processing
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       await expect(client.asynch.emotions('req-123', 3, 100)).rejects.toThrow(
         'Prediction not available after 3 attempts. The request may still be processing.'
       );
@@ -301,31 +302,87 @@ describe('AsyncAudio', () => {
 
     test('should handle server errors gracefully', async () => {
       nock('https://test-api.com')
-        .get('/prediction')
-        .query({ request_id: 'req-123' })
+        .get('/v1/asynch/emotion/status/req-123')
         .reply(500)
-        .get('/prediction')
-        .query({ request_id: 'req-123' })
-        .reply(200, { emotions: { happy: 1.0 } });
+        .get('/v1/asynch/emotion/status/req-123')
+        .reply(200, { emotions: [], status: 'completed' });
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       const result = await client.asynch.emotions('req-123', 5, 100);
-      
-      expect(result).toEqual({ emotions: { happy: 1.0 } });
+
+      expect(result).toEqual({ emotions: [], status: 'completed' });
     });
 
     test('should include correct headers', async () => {
       const scope = nock('https://test-api.com')
-        .get('/prediction')
+        .get('/v1/asynch/emotion/status/req-123')
         .matchHeader('x-api-key', 'test-api-key')
-        .matchHeader('User-Agent', 'valenceai/0.4.1')
-        .query({ request_id: 'req-123' })
-        .reply(200, { emotions: {} });
+        .matchHeader('User-Agent', 'valenceai/1.0.0')
+        .reply(200, { emotions: [], status: 'completed' });
 
-      const client = new ValenceClient();
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
       await client.asynch.emotions('req-123');
-      
+
       expect(scope.isDone()).toBe(true);
     });
+
+    test('should get timeline data', async () => {
+      const mockResponse = {
+        emotions: [
+          { timestamp: 0.5, emotion: 'happy' },
+          { timestamp: 1.5, emotion: 'sad' }
+        ],
+        status: 'completed'
+      };
+
+      nock('https://test-api.com')
+        .get('/v1/asynch/emotion/status/req-123')
+        .reply(200, mockResponse);
+
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
+      const timeline = await client.asynch.getTimeline('req-123');
+
+      expect(timeline.length).toBe(2);
+      expect(timeline[0].emotion).toBe('happy');
+    });
+
+    test('should get emotion at specific time', async () => {
+      const mockResponse = {
+        emotions: [
+          { timestamp: 0.5, start_time: 0.0, end_time: 1.0, emotion: 'happy' },
+          { timestamp: 1.5, start_time: 1.0, end_time: 2.0, emotion: 'sad' }
+        ],
+        status: 'completed'
+      };
+
+      nock('https://test-api.com')
+        .get('/v1/asynch/emotion/status/req-123')
+        .reply(200, mockResponse);
+
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
+      const emotion = await client.asynch.getEmotionAtTime('req-123', 0.7);
+
+      expect(emotion.emotion).toBe('happy');
+    });
+
+    test('should get dominant emotion', async () => {
+      const mockResponse = {
+        emotions: [
+          { timestamp: 0.5, emotion: 'happy' },
+          { timestamp: 1.5, emotion: 'happy' },
+          { timestamp: 2.5, emotion: 'sad' }
+        ],
+        status: 'completed'
+      };
+
+      nock('https://test-api.com')
+        .get('/v1/asynch/emotion/status/req-123')
+        .reply(200, mockResponse);
+
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
+      const dominant = await client.asynch.getDominantEmotion('req-123');
+
+      expect(dominant).toBe('happy');
+    });
   });
 });

package/tests/client.test.js

@@ -1,42 +1,27 @@
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
-import { getHeaders } from '../src/client.js';
+import { describe, test, expect } from '@jest/globals';
 
 describe('Client', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
   describe('getHeaders', () => {
     test('should return headers with API key', async () => {
+      // Test with a specific API key set in environment
+      const originalKey = process.env.VALENCE_API_KEY;
       process.env.VALENCE_API_KEY = 'test-api-key';
-      
+
       // Re-import to get fresh config
       const { getHeaders: freshGetHeaders } = await import('../src/client.js?' + Math.random());
-      
+
       const headers = freshGetHeaders();
-      
+
       expect(headers).toEqual({
         'x-api-key': 'test-api-key',
         'User-Agent': 'valenceai/0.4.1'
       });
-    });
 
-    test('should throw error when API key is missing', () => {
-      delete process.env.VALENCE_API_KEY;
-      
-      expect(() => getHeaders()).toThrow('VALENCE_API_KEY is required but not configured');
+      // Restore original
+      process.env.VALENCE_API_KEY = originalKey;
     });
 
-    test('should throw error when API key is empty string', () => {
-      process.env.VALENCE_API_KEY = '';
-      
-      expect(() => getHeaders()).toThrow('VALENCE_API_KEY is required but not configured');
-    });
+    // Note: API key validation is thoroughly tested in ValenceClient tests
+    // getHeaders() is an internal utility function that's always called with a valid config
   });
 });

package/tests/config.test.js

@@ -1,5 +1,5 @@
 import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
-import { config, validateConfig } from '../src/config.js';
+import { validateConfig } from '../src/config.js';
 
 describe('Config', () => {
   const originalEnv = process.env;
@@ -15,37 +15,37 @@ describe('Config', () => {
   describe('config object', () => {
     test('should load from environment variables', async () => {
       process.env.VALENCE_API_KEY = 'test-key';
-      process.env.VALENCE_DISCRETE_URL = 'https://test-short.com';
-      process.env.VALENCE_ASYNCH_URL = 'https://test-long.com';
+      process.env.VALENCE_API_BASE_URL = 'https://test-base.com';
+      process.env.VALENCE_WEBSOCKET_URL = 'wss://test-websocket.com';
       process.env.VALENCE_LOG_LEVEL = 'debug';
 
       // Re-import to get fresh config
       const { config: freshConfig } = await import('../src/config.js?' + Math.random());
 
       expect(freshConfig.apiKey).toBe('test-key');
-      expect(freshConfig.discreteAudioUrl).toBe('https://test-short.com');
-      expect(freshConfig.asyncAudioUrl).toBe('https://test-long.com');
+      expect(freshConfig.baseUrl).toBe('https://test-base.com');
+      expect(freshConfig.websocketUrl).toBe('wss://test-websocket.com');
       expect(freshConfig.logLevel).toBe('debug');
     });
 
     test('should use default URLs when not provided', async () => {
       process.env.VALENCE_API_KEY = 'test-key';
-      delete process.env.VALENCE_DISCRETE_URL;
-      delete process.env.VALENCE_ASYNCH_URL;
+      delete process.env.VALENCE_API_BASE_URL;
+      delete process.env.VALENCE_WEBSOCKET_URL;
 
       // Re-import to get fresh config
       const { config: freshConfig } = await import('../src/config.js?' + Math.random());
 
-      expect(freshConfig.discreteAudioUrl).toBe('https://xc8n2bo4f0.execute-api.us-west-2.amazonaws.com/emotionprediction');
-      expect(freshConfig.asyncAudioUrl).toBe('https://wsgol61783.execute-api.us-west-2.amazonaws.com/prod');
+      expect(freshConfig.baseUrl).toBe('https://demo.getvalenceai.com');
+      expect(freshConfig.websocketUrl).toBe('wss://demo.getvalenceai.com');
     });
 
     test('should use default log level when not provided', async () => {
       delete process.env.VALENCE_LOG_LEVEL;
-      
+
       // Re-import to get fresh config
       const { config: freshConfig } = await import('../src/config.js?' + Math.random());
-      
+
       expect(freshConfig.logLevel).toBe('info');
     });
   });
@@ -53,8 +53,8 @@ describe('Config', () => {
   describe('validateConfig', () => {
     test('should pass with valid configuration', () => {
       process.env.VALENCE_API_KEY = 'test-key';
-      process.env.VALENCE_DISCRETE_URL = 'https://test-short.com';
-      process.env.VALENCE_ASYNCH_URL = 'https://test-long.com';
+      process.env.VALENCE_API_BASE_URL = 'https://test-base.com';
+      process.env.VALENCE_WEBSOCKET_URL = 'wss://test-websocket.com';
       process.env.VALENCE_LOG_LEVEL = 'info';
 
       expect(() => validateConfig()).not.toThrow();
@@ -63,28 +63,28 @@ describe('Config', () => {
     test('should throw when API key is missing', async () => {
       delete process.env.VALENCE_API_KEY;
       const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
-      expect(() => freshValidateConfig()).toThrow('VALENCE_API_KEY environment variable is required');
+      expect(() => freshValidateConfig()).toThrow('VALENCE_API_KEY is required');
     });
 
-    test('should throw when short URL is not HTTPS', async () => {
+    test('should throw when base URL is not HTTPS', async () => {
       process.env.VALENCE_API_KEY = 'test-key';
-      process.env.VALENCE_DISCRETE_URL = 'http://test-short.com';
+      process.env.VALENCE_API_BASE_URL = 'http://test-base.com';
       const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
-      expect(() => freshValidateConfig()).toThrow('VALENCE_DISCRETE_URL must be a valid HTTPS URL');
+      expect(() => freshValidateConfig()).toThrow('baseUrl must be a valid HTTPS URL');
     });
 
-    test('should throw when long URL is not HTTPS', async () => {
+    test('should throw when websocket URL is not WSS', async () => {
       process.env.VALENCE_API_KEY = 'test-key';
-      process.env.VALENCE_ASYNCH_URL = 'http://test-long.com';
+      process.env.VALENCE_WEBSOCKET_URL = 'ws://test-websocket.com';
       const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
-      expect(() => freshValidateConfig()).toThrow('VALENCE_ASYNCH_URL must be a valid HTTPS URL');
+      expect(() => freshValidateConfig()).toThrow('websocketUrl must be a valid WSS URL');
     });
 
     test('should throw with invalid log level', async () => {
       process.env.VALENCE_API_KEY = 'test-key';
       process.env.VALENCE_LOG_LEVEL = 'invalid';
       const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
-      expect(() => freshValidateConfig()).toThrow('VALENCE_LOG_LEVEL must be one of: debug, info, warn, error');
+      expect(() => freshValidateConfig()).toThrow('logLevel must be one of: debug, info, warn, error');
     });
   });
 });