valenceai 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.3] - 2025-01-28
+
+### Added
+
+- **`getEmotionCounts()` method**: Returns an object of emotion occurrence counts for the entire audio file (e.g., `{happy: 10, sad: 3, angry: 8, neutral: 9}`)
+- **`majorityEmotion()` method**: Alias for `getDominantEmotion()`, returns the most frequently occurring emotion as a string
+
+### Technical Improvements
+
+- **Refactored `getDominantEmotion()`**: Now uses `getEmotionCounts()` internally to avoid code duplication
+
+### Usage Example
+
+```javascript
+import { ValenceClient } from 'valenceai';
+
+const client = new ValenceClient({ apiKey: 'your_api_key' });
+const requestId = await client.asynch.upload('audio.wav');
+const result = await client.asynch.emotions(requestId);
+
+// Get emotion counts
+const counts = await client.asynch.getEmotionCounts(requestId);
+// Returns: { happy: 10, sad: 3, angry: 8, neutral: 9 }
+
+// Get majority emotion
+const majority = await client.asynch.majorityEmotion(requestId);
+// Returns: "happy"
+```
+
 ## [1.0.1] - 2025-12-29
 
 ### Fixed

package/README.md

@@ -1,15 +1,13 @@
 # Valence SDK for Emotion Detection
 
-**valenceai** is a Node.js SDK for interacting with the [Valence AI](https://getvalenceai.com) Pulse API for emotion detection. It provides a convenient interface to upload audio files, stream real-time audio, and retrieve detected emotional states.
+**valenceai** is a Node.js SDK for interacting with the [Valence AI](https://getvalenceai.com) API for emotion analysis. It provides a convenient interface to upload audio files, stream real-time audio, and retrieve detected emotional states.
 
 ## Features
 
 - **Discrete audio processing** - Real-time analysis for short audio clips (4-10s)
-- **Async audio processing** - Multipart streaming for long files with timeline data
+- **Asynch audio processing** - Multipart streaming for long files with timeline data
 - **Streaming API** - Real-time WebSocket streaming for live audio
 - **Rate limiting** - Monitor API usage and limits
-- **Model selection** - Choose between 4emotions and 7emotions models
-- **Timeline analysis** - Get emotion changes over time with timestamps
 - **Environment configuration** - Built-in support for .env files
 - **Enhanced logging** - Configurable log levels with timestamps
 - **Robust error handling** - Comprehensive validation and error recovery
@@ -17,28 +15,19 @@
 - **100% tested** - Comprehensive test suite with high coverage
 - **Security focused** - Input validation and secure error handling
 
-The emotional classification model used in our APIs is optimized for North American English conversational data.
-
-## Emotion Models
-
-The SDK supports two emotion detection models:
-
-- **4emotions** (default): angry, happy, neutral, sad
-- **7emotions**: happy, sad, angry, neutral, surprised, disgusted, calm
-
-The number of emotions, emotional buckets, and language support can be customized. If you are interested in a custom model, please [contact us](https://www.getvalenceai.com/contact).
+The emotional classification model used in our APIs is optimized for North American English conversational data. The model detects four emotions: angry, happy, neutral, and sad.
 
 ## API Overview
 
-| API | Best For | Input | Output | Response Time |
-|-----|----------|-------|--------|---------------|
-| **Discrete** | Real-time analysis | Short audio (4-10s) | Single emotion prediction | 100-500ms |
-| **Async** | Pre-recorded files | Long audio (up to 1GB) | Timeline with emotion changes | Depends on file size |
-| **Streaming** | Live audio streams | Audio chunks via WebSocket | Real-time emotion updates | Near real-time |
+| API | Best For | Input | Output |
+|-----|----------|-------|--------|
+| **Discrete** | Real-time analysis | Short audio (4-10s) | Single emotion prediction |
+| **Asynch** | Pre-recorded files | Long audio (up to 1GB) | Timeline with emotion changes |
+| **Streaming** | Live audio streams | Audio chunks via WebSocket | Real-time emotion updates |
 
-## Async API Processing Workflow
+## Asynch API Processing Workflow
 
-The Async API uses a multi-step process to handle long audio files. Understanding this workflow is crucial for proper implementation:
+The Asynch API uses a multi-step process to handle long audio files. Understanding this workflow is crucial for proper implementation:
 
 ### 1. Upload Phase (Client-Side)
 
@@ -61,7 +50,7 @@ After upload completes, the server automatically:
 - Stores results in database
 - Updates status to `completed`
 
-**Processing Time**: Typically 1-2 minutes for a 60-minute audio file. The exact time depends on file length and current server load.
+**Processing Time**: Varies based on file length and server load.
 
 ### 3. Results Retrieval (Client-Side)
 
@@ -87,8 +76,8 @@ When you call `client.asynch.emotions(requestId)`:
 ### Important Notes
 
 - **The `requestId` is NOT a completion indicator** - It's just a tracking ID
-- **`upload()` completing does NOT mean results are ready** - It only means the file is in S3
-- **Background processing takes time** - Plan for 1-2 minutes per hour of audio
+- **`upload()` completing does NOT mean results are ready** - It only means the file is uploaded
+- **Background processing takes time** - Processing time varies based on file length and server load
 - **You can check status anytime** - The `requestId` remains valid for retrieving results
 
 ## Installation
@@ -106,20 +95,23 @@ import { ValenceClient } from 'valenceai';
 const client = new ValenceClient({ apiKey: 'your_api_key' });
 
 // Discrete API - Quick emotion detection
-const result = await client.discrete.emotions('short_audio.wav', '4emotions');
-console.log(`Emotion: ${result.dominant_emotion}`);
+const result = await client.discrete.emotions('short_audio.wav');
+console.log(`Emotion: ${result.main_emotion}`);
 
-// Async API - Long audio with timeline
-// Step 1: Upload file to S3 (returns tracking ID, NOT results)
+// Asynch API - Long audio with timeline
+// Step 1: Upload file (returns tracking ID, NOT results)
 const requestId = await client.asynch.upload('long_audio.wav');
 // Step 2: Wait for server processing and get results (polls until complete)
 const emotions = await client.asynch.emotions(requestId, 30, 10000);
-// Step 3: Access timeline and dominant emotion from results
-const timeline = await client.asynch.getTimeline(requestId);
-const dominant = await client.asynch.getDominantEmotion(requestId);
+// Step 3: Access emotion data from results
+const emotionList = emotions.emotions;  // List of emotion predictions with timestamps
+
+// Get summary statistics
+const majority = await client.asynch.majorityEmotion(requestId);  // Most frequent emotion
+const counts = await client.asynch.emotionCounts(requestId);  // { happy: 10, sad: 3, ... }
 
 // Streaming API - Real-time audio
-const stream = client.streaming.connect('4emotions');
+const stream = client.streaming.connect();
 stream.on('prediction', (data) => console.log(data.main_emotion));
 stream.connect();
 stream.sendAudio(audioBuffer);
@@ -151,7 +143,9 @@ const client = new ValenceClient({
   baseUrl: 'https://custom.api',    // Custom API endpoint (optional)
   websocketUrl: 'wss://custom.api', // Custom WebSocket endpoint (optional)
   partSize: 5 * 1024 * 1024,        // Upload chunk size (default: 5MB)
-  maxRetries: 3                     // Max retry attempts (default: 3)
+  maxRetries: 3,                    // Max retry attempts (default: 3)
+  comprehensiveOutput: false        // When false: returns timestamp, main_emotion, confidence only.
+                                    // When true: also includes all_predictions with all emotion confidences (default: false)
 });
 ```
 
@@ -163,16 +157,10 @@ For short audio files requiring immediate emotion detection.
 
 ```javascript
 // File upload
-const result = await client.discrete.emotions(
-  'audio.wav',
-  '4emotions'  // or '7emotions'
-);
+const result = await client.discrete.emotions('audio.wav');
 
 // In-memory audio array
-const result = await client.discrete.emotions(
-  [0.1, 0.2, 0.3, ...],
-  '4emotions'
-);
+const result = await client.discrete.emotions([0.1, 0.2, 0.3, ...]);
 ```
 
 **Response:**
@@ -184,31 +172,31 @@ const result = await client.discrete.emotions(
     angry: 0.05,
     neutral: 0.05
   },
-  dominant_emotion: 'happy'
+  main_emotion: 'happy'
 }
 ```
 
-### Async API
+### Asynch API
 
 For long audio files with timeline analysis.
 
-**Workflow**: The Async API uses a 3-step process:
+**Workflow**: The Asynch API uses a 3-step process:
 
-1. **Upload** (`upload()`) - Multipart upload to S3, returns `requestId` (tracking ID)
+1. **Upload** (`upload()`) - Multipart upload, returns `requestId` (tracking ID)
 2. **Background Processing** (automatic) - Server processes audio in 5-second chunks
 3. **Results Retrieval** (`emotions()`) - Polls status endpoint until processing completes
 
-**Processing Time**: Typically 1-2 minutes per hour of audio.
+**Processing Time**: Varies based on file length and server load.
 
 **Status Progression**: `initiated` → `upload_completed` → `processing` → `completed`
 
 #### Upload Audio
 
 ```javascript
-// Upload file to S3 (multipart upload)
+// Upload file (multipart upload)
 const requestId = await client.asynch.upload('long_audio.wav');
 // Returns: requestId (tracking ID, NOT completion signal)
-// File is uploaded to S3 but NOT processed yet
+// File is uploaded but NOT processed yet
 ```
 
 #### Get Emotion Results
@@ -249,17 +237,18 @@ const result = await client.asynch.emotions(
 }
 ```
 
-#### Timeline Analysis
+Note: The `all_predictions` field is only included when `comprehensiveOutput: true` is set in the client constructor.
 
-```javascript
-// Get full timeline
-const timeline = await client.asynch.getTimeline(requestId);
+#### Helper Methods
 
-// Get emotion at specific time
-const emotion = await client.asynch.getEmotionAtTime(requestId, 5.2);
+```javascript
+// Get the most frequently occurring emotion across the entire file
+const majority = await client.asynch.majorityEmotion(requestId);
+// Returns: "happy"
 
-// Get dominant emotion across entire audio
-const dominant = await client.asynch.getDominantEmotion(requestId);
+// Get emotion occurrence counts for the entire file
+const counts = await client.asynch.emotionCounts(requestId);
+// Returns: { happy: 10, sad: 3, angry: 8, neutral: 9 }
 ```
 
 ### Streaming API
@@ -268,7 +257,7 @@ For real-time emotion detection on live audio streams.
 
 ```javascript
 // Create streaming connection
-const stream = client.streaming.connect('4emotions');
+const stream = client.streaming.connect();
 
 // Register event handlers
 stream.on('prediction', (data) => {
@@ -309,10 +298,12 @@ stream.disconnect();
     angry: 0.03,
     neutral: 0.05
   },
-  timestamp: 1234567890
+  timestamp: 1706486400000  // Unix timestamp (UTC) in milliseconds
 }
 ```
 
+The `timestamp` is a Unix timestamp (UTC) in milliseconds representing when the server generated the prediction.
+
 ### Rate Limit API
 
 Monitor your API usage and limits.
@@ -354,7 +345,7 @@ console.log(health);
 ### API-Specific Requirements
 
 - **Discrete API**: 4-10 seconds per file
-- **Async API**: Minimum 5 seconds, maximum 1 GB
+- **Asynch API**: Minimum 5 seconds, maximum 1 GB
 - **Streaming API**: Real-time audio chunks (Buffer or ArrayBuffer)
 
 For custom microphone specifications or stereo/multi-channel support, please [contact us](https://www.getvalenceai.com/contact).
@@ -382,16 +373,66 @@ node examples/uploadLong.js
 node examples/streamingAudio.js
 ```
 
+## Error Responses
+
+### Discrete API Errors
+
+| HTTP Status | Error Code | Description |
+|-------------|------------|-------------|
+| 400 | `AUDIO_TOO_SHORT` | Audio duration below minimum (4.5 seconds). Response includes `min_duration_seconds` and `actual_duration_seconds` |
+| 400 | Bad Request | Invalid request format or parameters |
+| 401 | Unauthorized | Invalid or missing API key |
+| 500 | Server Error | Internal server error |
+
+### Asynch API Errors
+
+| HTTP Status | Error Code | Description |
+|-------------|------------|-------------|
+| 400 | `AUDIO_TOO_SHORT` | Audio duration below minimum (5 seconds) |
+| 400 | Bad Request | Invalid request format or parameters |
+| 401 | Unauthorized | Invalid or missing API key |
+| 404 | Not Found | Request ID not found |
+| 500 | Server Error | Internal server error |
+
+**Asynch Status Values:**
+
+| Status | Meaning |
+|--------|---------|
+| `initiated` | Upload in progress |
+| `upload_completed` | Upload finished, awaiting processing |
+| `processing` | Server analyzing audio |
+| `completed` | Results ready |
+| `failed` | Processing failed |
+
+### Streaming API Errors
+
+| Event | Description |
+|-------|-------------|
+| `error` | Server-side error during streaming |
+| `warning` | Non-fatal warning from server |
+| `connect_error` | WebSocket connection failed |
+| `disconnect` | Connection closed |
+
+### Rate Limit API Errors
+
+| HTTP Status | Description |
+|-------------|-------------|
+| 401 | Unauthorized - Invalid API key |
+| 429 | Too Many Requests - Rate limit exceeded |
+| 500 | Server Error |
+
 ## Error Handling
 
 ```javascript
-import { ValenceClient } from 'valenceai';
+import { ValenceClient, AudioTooShortError } from 'valenceai';
 
 try {
   const client = new ValenceClient({ apiKey: 'your_key' });
   const result = await client.discrete.emotions('audio.wav');
 } catch (error) {
-  if (error.message.includes('API key')) {
+  if (error instanceof AudioTooShortError) {
+    console.error(`Audio too short: ${error.actualDuration}s (min: ${error.minDuration}s)`);
+  } else if (error.message.includes('API key')) {
     console.error('Authentication error:', error.message);
   } else if (error.message.includes('File not found')) {
     console.error('File error:', error.message);
@@ -440,8 +481,7 @@ npm publish --access public
 2. **Unified Client**: Single `ValenceClient` class with nested APIs
 3. **Streaming API**: New WebSocket-based real-time emotion detection
 4. **Rate Limiting**: New API for monitoring usage
-5. **Timeline Data**: Async API now returns detailed timestamp information
-6. **Model Selection**: Explicit model parameter for 4emotions or 7emotions
+5. **Timeline Data**: Asynch API now returns detailed timestamp information
 
 ### Updating Your Code
 
@@ -453,10 +493,10 @@ const result = await predictDiscreteAudioEmotion('file.wav');
 // New (v1.0.0)
 import { ValenceClient } from 'valenceai';
 const client = new ValenceClient({ apiKey: 'your_key' });
-const result = await client.discrete.emotions('file.wav', '4emotions');
+const result = await client.discrete.emotions('file.wav');
 
 // New streaming capability
-const stream = client.streaming.connect('4emotions');
+const stream = client.streaming.connect();
 stream.on('prediction', callback);
 await stream.connect();
 ```
@@ -467,7 +507,6 @@ await stream.connect();
 - `uploadAsyncAudio()` → `client.asynch.upload()`
 - `getEmotions()` → `client.asynch.emotions()`
 - All methods now require creating a `ValenceClient` instance first
-- Model parameter is now required and explicit
 
 See [CHANGELOG.md](./CHANGELOG.md) for complete migration guide.
 
@@ -481,8 +520,8 @@ import { ValenceClient } from 'valenceai';
 const client: ValenceClient = new ValenceClient({ apiKey: 'your_key' });
 
 // Full type inference and autocomplete
-const result = await client.discrete.emotions('audio.wav', '4emotions');
-// result.dominant_emotion is typed
+const result = await client.discrete.emotions('audio.wav');
+// result.main_emotion is typed
 ```
 
 ## Contributing

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valenceai",
-    "version": "1.0.1",
+    "version": "1.0.3",
     "type": "module",
     "main": "src/index.js",
     "description": "Node.js SDK for Valence AI Emotion Detection API - Real-time, Async, and Streaming Support",

package/src/errors.js

@@ -0,0 +1,26 @@
+/**
+ * Base error class for Valence SDK errors.
+ */
+export class ValenceSDKError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'ValenceSDKError';
+  }
+}
+
+/**
+ * Error thrown when the audio file is shorter than the minimum required duration.
+ */
+export class AudioTooShortError extends ValenceSDKError {
+  /**
+   * @param {string} message - Error message
+   * @param {number|null} minDuration - Minimum required duration in seconds
+   * @param {number|null} actualDuration - Actual duration of the provided audio in seconds
+   */
+  constructor(message, minDuration = null, actualDuration = null) {
+    super(message);
+    this.name = 'AudioTooShortError';
+    this.minDuration = minDuration;
+    this.actualDuration = actualDuration;
+  }
+}

package/src/index.js

@@ -1,2 +1,3 @@
 export { ValenceClient } from './valenceClient.js';
-export { validateConfig } from './config.js';
+export { validateConfig } from './config.js';
+export { ValenceSDKError, AudioTooShortError } from './errors.js';

package/src/valenceClient.js

@@ -6,6 +6,7 @@ import { getHeaders } from './client.js';
 import { log } from './utils/logger.js';
 import { RateLimitAPI } from './rateLimit.js';
 import { StreamingAPI } from './streaming.js';
+import { AudioTooShortError } from './errors.js';
 
 /**
  * Client for discrete (short) audio processing
@@ -87,6 +88,14 @@ class DiscreteClient {
       log(`Error getting discrete emotions: ${error.message}`, 'error');
 
       if (error.response) {
+        // Check for AUDIO_TOO_SHORT error
+        if (error.response.status === 400 && error.response.data?.error_code === 'AUDIO_TOO_SHORT') {
+          throw new AudioTooShortError(
+            error.response.data.error || 'Audio file is too short',
+            error.response.data.min_duration_seconds,
+            error.response.data.actual_duration_seconds
+          );
+        }
         throw new Error(`API error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
       } else if (error.request) {
         throw new Error('Network error: Unable to reach the API');
@@ -101,10 +110,11 @@ class DiscreteClient {
  * Client for async (long) audio processing
  */
 class AsyncClient {
-  constructor(clientConfig, partSize = 5 * 1024 * 1024, maxRetries = 3) {
+  constructor(clientConfig, partSize = 5 * 1024 * 1024, maxRetries = 3, comprehensiveOutput = false) {
     this.config = clientConfig;
     this.partSize = partSize;
     this.maxRetries = maxRetries;
+    this.comprehensiveOutput = comprehensiveOutput;
   }
 
   /**
@@ -190,8 +200,16 @@ class AsyncClient {
       return data.request_id;
     } catch (error) {
       log(`Error uploading async audio: ${error.message}`, 'error');
-      
+
       if (error.response) {
+        // Check for AUDIO_TOO_SHORT error
+        if (error.response.status === 400 && error.response.data?.error_code === 'AUDIO_TOO_SHORT') {
+          throw new AudioTooShortError(
+            error.response.data.error || 'Audio file is too short',
+            error.response.data.min_duration_seconds,
+            error.response.data.actual_duration_seconds
+          );
+        }
         throw new Error(`API error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
       } else if (error.request) {
         throw new Error('Network error: Unable to reach the API');
@@ -231,6 +249,7 @@ class AsyncClient {
 
     const url = `${this.config.baseUrl}/v1/asynch/emotion/status/${requestId}`;
     const intervalMs = intervalSeconds * 1000;
+    const params = this.comprehensiveOutput ? { comprehensive_output: 'true' } : {};
 
     for (let i = 0; i < maxAttempts; i++) {
       try {
@@ -238,6 +257,7 @@ class AsyncClient {
 
         const res = await axios.get(url, {
           headers: { 'x-api-key': this.config.apiKey },
+          params,
           timeout: 15000
         });
 
@@ -304,20 +324,44 @@ class AsyncClient {
    * @returns {Promise<string|null>} The dominant emotion across the timeline
    */
   async getDominantEmotion(requestId) {
+    const counts = await this.getEmotionCounts(requestId);
+    if (!counts || Object.keys(counts).length === 0) {
+      return null;
+    }
+
+    return Object.keys(counts).reduce((a, b) =>
+      counts[a] > counts[b] ? a : b
+    );
+  }
+
+  /**
+   * Alias for getDominantEmotion. Get the most frequently occurring emotion.
+   * @param {string} requestId - Request ID from upload method
+   * @returns {Promise<string|null>} The dominant emotion across the timeline
+   */
+  async majorityEmotion(requestId) {
+    return this.getDominantEmotion(requestId);
+  }
+
+  /**
+   * Get counts of each emotion in the timeline
+   * @param {string} requestId - Request ID from upload method
+   * @returns {Promise<Object>} Object mapping emotion names to their occurrence counts
+   *                           (e.g., {happy: 10, sad: 3, angry: 8, neutral: 9})
+   */
+  async getEmotionCounts(requestId) {
     const timeline = await this.getTimeline(requestId);
     if (!timeline || timeline.length === 0) {
-      return null;
+      return {};
     }
 
-    const emotionCounts = {};
+    const counts = {};
     for (const emotionData of timeline) {
       const emotion = emotionData.emotion;
-      emotionCounts[emotion] = (emotionCounts[emotion] || 0) + 1;
+      counts[emotion] = (counts[emotion] || 0) + 1;
     }
 
-    return Object.keys(emotionCounts).reduce((a, b) =>
-      emotionCounts[a] > emotionCounts[b] ? a : b
-    );
+    return counts;
   }
 }
 
@@ -333,6 +377,7 @@ export class ValenceClient {
    * @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)
+   * @param {boolean} options.comprehensiveOutput - Include all_predictions in async emotion responses (default: false)
    */
   constructor(options = {}) {
     // Build configuration with priority: parameter > env var > default
@@ -351,10 +396,11 @@ export class ValenceClient {
 
     const partSize = options.partSize || 5 * 1024 * 1024;
     const maxRetries = options.maxRetries || 3;
+    const comprehensiveOutput = options.comprehensiveOutput || false;
 
     // Initialize nested clients
     this.discrete = new DiscreteClient(this.config);
-    this.asynch = new AsyncClient(this.config, partSize, maxRetries);
+    this.asynch = new AsyncClient(this.config, partSize, maxRetries, comprehensiveOutput);
     this.rateLimit = new RateLimitAPI(this.config);
     this.streaming = new StreamingAPI(this.config);
   }

package/tests/asyncAudio.test.js

@@ -2,6 +2,7 @@ import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globa
 import nock from 'nock';
 import fs from 'fs';
 import { ValenceClient } from '../src/valenceClient.js';
+import { AudioTooShortError } from '../src/errors.js';
 
 describe('AsyncAudio', () => {
   const originalEnv = process.env;
@@ -166,7 +167,7 @@ describe('AsyncAudio', () => {
     test('should handle API errors', async () => {
       fsMock.mockReturnValue(true);
       statMock.mockReturnValue({ size: 5242880 });
-      
+
       nock('https://test-api.com')
         .get('/upload/initiate')
         .reply(400, { message: 'Invalid request' });
@@ -176,6 +177,34 @@ describe('AsyncAudio', () => {
         'API error (400): Invalid request'
       );
     });
+
+    test('should throw AudioTooShortError when audio is too short', async () => {
+      fsMock.mockReturnValue(true);
+      statMock.mockReturnValue({ size: 1000 }); // Small file
+
+      nock('https://test-api.com')
+        .post('/v1/asynch/emotion/upload/initiate')
+        .query(true)
+        .reply(400, {
+          error: 'Audio file is too short. Minimum duration: 4.5 seconds, provided: 1.00 seconds',
+          error_code: 'AUDIO_TOO_SHORT',
+          min_duration_seconds: 4.5,
+          actual_duration_seconds: 1.0
+        });
+
+      const client = new ValenceClient({ apiKey: 'test-api-key' });
+
+      try {
+        await client.asynch.upload('short_audio.wav');
+        expect.fail('Should have thrown AudioTooShortError');
+      } catch (error) {
+        expect(error).toBeInstanceOf(AudioTooShortError);
+        expect(error.name).toBe('AudioTooShortError');
+        expect(error.minDuration).toBe(4.5);
+        expect(error.actualDuration).toBe(1.0);
+        expect(error.message).toContain('too short');
+      }
+    });
   });
 
   describe('getEmotions', () => {

package/tests/discreteAudio.test.js

@@ -2,6 +2,7 @@ import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globa
 import nock from 'nock';
 import fs from 'fs';
 import { ValenceClient } from '../src/valenceClient.js';
+import { AudioTooShortError } from '../src/errors.js';
 
 describe('DiscreteAudio', () => {
   const originalEnv = process.env;
@@ -152,7 +153,7 @@ describe('DiscreteAudio', () => {
 
     test('should include correct headers', async () => {
       fsMock.mockReturnValue(true);
-      
+
       const scope = nock('https://test-api.com')
         .post('/predict?model=4emotions')
         .matchHeader('x-api-key', 'test-api-key')
@@ -161,8 +162,48 @@ describe('DiscreteAudio', () => {
 
       const client = new ValenceClient();
       await client.discrete.emotions('test.wav');
-      
+
       expect(scope.isDone()).toBe(true);
     });
+
+    test('should throw AudioTooShortError when audio is too short', async () => {
+      fsMock.mockReturnValue(true);
+
+      nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .reply(400, {
+          error: 'Audio file is too short. Minimum duration: 4.5 seconds, provided: 1.50 seconds',
+          error_code: 'AUDIO_TOO_SHORT',
+          min_duration_seconds: 4.5,
+          actual_duration_seconds: 1.5
+        });
+
+      const client = new ValenceClient();
+
+      try {
+        await client.discrete.emotions('short_audio.wav');
+        expect.fail('Should have thrown AudioTooShortError');
+      } catch (error) {
+        expect(error).toBeInstanceOf(AudioTooShortError);
+        expect(error.name).toBe('AudioTooShortError');
+        expect(error.minDuration).toBe(4.5);
+        expect(error.actualDuration).toBe(1.5);
+        expect(error.message).toContain('too short');
+      }
+    });
+
+    test('should throw regular error for other 400 errors', async () => {
+      fsMock.mockReturnValue(true);
+
+      nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .reply(400, { message: 'Invalid file format' });
+
+      const client = new ValenceClient();
+
+      await expect(client.discrete.emotions('test.wav')).rejects.toThrow(
+        'API error (400): Invalid file format'
+      );
+    });
   });
 });