voicemix 1.0.6 → 1.1.4

package/README.md

@@ -15,6 +15,7 @@ Create a `.env` file in your project root with your API keys:
 ```plaintext
 ELEVENLABS_API_KEY="6e04xxxxxxxxxxxxxxxxxxxxxxxxa9da"
 RESEMBLE_API_KEY="9YWxxxxxxxxxxxxxxxxxmgtt"
+CARTESIA_API_KEY="sk_car_xxxxxxxxxxxxxxxxxxxxjr"
 ```
 
 ## Usage
@@ -34,8 +35,24 @@ voiceMix
     .save();
 ```
 
+### Using ElevenLabs v3 Model
+
+```javascript
+const voiceMix = new VoiceMix();
+
+voiceMix
+    .v3() // Use the latest ElevenLabs v3 model
+    .voice('EbhcCfMvNsbvjN6OhjpJ')
+    .say('Hello! This is using the ElevenLabs v3 model.')
+    .save();
+```
+
+The v3 model is the latest and most advanced model from ElevenLabs, providing the most natural and expressive voice generation.
+
 ### Advanced Usage
 
+#### Using Resemble AI
+
 ```javascript
 const voiceMix = new VoiceMix();
 
@@ -48,6 +65,20 @@ voiceMix
     .save();
 ```
 
+#### Using Cartesia
+
+```javascript
+const voiceMix = new VoiceMix();
+
+voiceMix
+    .useCartesia()  // https://cartesia.ai/
+    .voice('your-cartesia-voice-id') // Select specific voice from your Cartesia account
+    .say('Your text here')
+    .save();
+```
+
+**Note:** You need to use a valid voice ID from your Cartesia account. You can find available voices in your Cartesia dashboard.
+
 ### Batch Processing
 
 You can process multiple lines of text using a JSON configuration:
@@ -86,7 +117,15 @@ Example `lines.json`:
 - Multiple voice support
 - Language selection
 - Voice prompts for style control (Resemble AI)
-- Support for different TTS engines
+- Support for multiple TTS providers:
+  - ElevenLabs (including v3 model)
+  - Resemble AI
+  - Cartesia
+- Support for different ElevenLabs models:
+  - `monolingual_v1()` - Original English model
+  - `multilingual_v1()` - First multilingual model
+  - `multilingual_v2()` - Improved multilingual model (default)
+  - `v3()` - Latest and most advanced model
 - Simple chainable API
 
 ## License

package/demo/index.js

@@ -9,15 +9,15 @@ const script = JSON.parse(fs.readFileSync('./lines.json', 'utf8'));
 const voiceMix = new VoiceMix()//.useResemble().lang('en-US');
 
 // Process each line in the script
-for (const entry of script) {
+// for (const entry of script) {
 
-    voiceMix
-        .prompt(entry.prompt || 'Friendly and conversational tone')
-        // .voice('ba875a0a') // Peter v2
-        .voice('EbhcCfMvNsbvjN6OhjpJ')
-        .say(entry.english)
-        .save();
-}
+//     voiceMix
+//         .prompt(entry.prompt || 'Friendly and conversational tone')
+//         // .voice('ba875a0a') // Peter v2
+//         .voice('EbhcCfMvNsbvjN6OhjpJ')
+//         .say(entry.english)
+//         .save();
+// }
 
 // const voiceMix = new VoiceMix();
 
@@ -39,4 +39,19 @@ for (const entry of script) {
 //     // .voice('fcf8490c')
 //     .voice('ba875a0a') // Peter v2
 //     .say(line)
-//     .save();
+//     .save();
+
+// Example using Cartesia
+// Note: Replace with your actual Cartesia voice ID from your account
+// voiceMix.useCartesia()
+//     .voice('6ccbfb76-1fc6-48f7-b71d-91ac6298247b') // Cartesia voice ID from your account
+//     .say('<emotion value="happy" />Hmm… okay, let me think… yeah, this is actually kind of fun. [laughter] Let\'s dive in.')
+//     .save();
+
+// Example using ElevenLabs v3 model
+// v3 is the latest and most advanced model from ElevenLabs
+voiceMix
+    .v3() // Use the ElevenLabs v3 model
+    .voice('dxvGlXoa4TLMyfYR6uC9') // ElevenLabs voice ID
+    .say('[sorprendida] gracias! [risas] dos personas creyeron en mí cuando nadie más lo hizo!')
+    .save();

package/index.js

@@ -3,6 +3,7 @@ import path from 'path';
 import hashFactory from 'hash-factory';
 import { ElevenLabsProvider } from './providers/elevenlabs.js';
 import { ResembleProvider } from './providers/resemble.js';
+import { CartesiaProvider } from './providers/cartesia.js';
 import { ValidationError, formatError } from './errors.js';
 
 const hash = hashFactory({ words: true, alpha: true });
@@ -54,6 +55,12 @@ export class VoiceMix {
         return this;
     }
 
+    useCartesia(apiKey) {
+        this.provider = new CartesiaProvider(apiKey);
+        this.providerType = 'cartesia';
+        return this;
+    }
+
     monolingual_v1() {
         if (this.providerType === 'elevenlabs') {
             this.provider.monolingual_v1();
@@ -75,6 +82,13 @@ export class VoiceMix {
         return this;
     }
 
+    v3() {
+        if (this.providerType === 'elevenlabs') {
+            this.provider.v3();
+        }
+        return this;
+    }
+
     setSampleRate(rate) {
         if (this.providerType === 'resemble') {
             this.provider.setSampleRate(rate);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "voicemix",
   "type": "module",
-  "version": "1.0.6",
-  "description": "🗣️ VoiceMix - A simple text-to-speech tool using ElevenLabs and Resemble AI APIs.",
+  "version": "1.1.4",
+  "description": "🗣️ VoiceMix - A simple text-to-speech tool using ElevenLabs, Cartesia and Resemble AI APIs.",
   "main": "index.js",
   "repository": {
     "type": "git",
@@ -28,6 +28,7 @@
     "synthesis",
     "prompt",
     "tone",
+    "cartesia",
     "clasen"
   ]
 }

package/providers/cartesia.js

@@ -0,0 +1,131 @@
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import { ProviderError } from '../errors.js';
+
+export class CartesiaProvider {
+    constructor(apiKey) {
+        this.apiKey = apiKey || process.env.CARTESIA_API_KEY;
+        this.baseUrl = 'https://api.cartesia.ai';
+        this.defaultSettings = {
+            model_id: 'sonic-3',
+            speed: 'normal',
+            generation_config: {
+                speed: 1,
+                volume: 1
+            }
+        };
+
+        if (!this.apiKey) {
+            throw new ProviderError('Cartesia API key is required', 'cartesia');
+        }
+    }
+
+    _getRequestOptions(voiceId, text, format = 'mp3') {
+        // Configure output format based on requested format
+        const outputFormat = format === 'mp3' 
+            ? { container: 'mp3', encoding: 'mp3', sample_rate: 44100 }
+            : { container: 'wav', encoding: 'pcm_f32le', sample_rate: 44100 };
+
+        return {
+            method: 'post',
+            url: `${this.baseUrl}/tts/bytes`,
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Cartesia-Version': '2024-06-10',
+                'Content-Type': 'application/json'
+            },
+            data: {
+                model_id: this.defaultSettings.model_id,
+                transcript: text,
+                voice: {
+                    mode: 'id',
+                    id: voiceId
+                },
+                output_format: outputFormat,
+                speed: this.defaultSettings.speed,
+                generation_config: this.defaultSettings.generation_config
+            },
+            responseType: 'stream'
+        };
+    }
+
+    async save(voiceId, text, format, filePath, fileName) {
+        try {
+            if (!voiceId) {
+                throw new ProviderError('Voice ID is required', 'cartesia');
+            }
+            if (!text) {
+                throw new ProviderError('Text is required', 'cartesia');
+            }
+            if (!filePath || !fileName) {
+                throw new ProviderError('File path and name are required', 'cartesia');
+            }
+
+            const response = await axios(this._getRequestOptions(voiceId, text, format));
+
+            if (!fs.existsSync(filePath)) {
+                fs.mkdirSync(filePath, { recursive: true });
+            }
+
+            const fullPath = path.join(filePath, fileName);
+            const writer = fs.createWriteStream(fullPath);
+            response.data.pipe(writer);
+
+            return new Promise((resolve, reject) => {
+                writer.on('finish', () => resolve(fullPath));
+                writer.on('error', (err) => {
+                    reject(new ProviderError(
+                        'Failed to write audio file',
+                        'cartesia',
+                        { path: fullPath, error: err.message }
+                    ));
+                });
+            });
+        } catch (error) {
+            if (error instanceof ProviderError) {
+                throw error;
+            }
+            
+            if (axios.isAxiosError(error)) {
+                // Try to read the error message from the response stream
+                let errorMessage = 'Failed to save audio from Cartesia API';
+                
+                if (error.response?.data) {
+                    try {
+                        // If data is a stream/buffer, try to read it
+                        if (typeof error.response.data.read === 'function') {
+                            const errorData = error.response.data.read();
+                            if (errorData) {
+                                errorMessage = errorData.toString('utf-8');
+                            }
+                        } else if (typeof error.response.data === 'string') {
+                            errorMessage = error.response.data;
+                        }
+                    } catch (readError) {
+                        // Keep default error message
+                    }
+                }
+                
+                const details = {
+                    status: error.response?.status,
+                    statusText: error.response?.statusText,
+                    message: errorMessage
+                };
+                
+                throw new ProviderError(
+                    errorMessage,
+                    'cartesia',
+                    details
+                );
+            }
+            
+            throw new ProviderError(
+                'An unexpected error occurred while saving audio',
+                'cartesia',
+                { originalError: error.message }
+            );
+        }
+    }
+}
+

package/providers/elevenlabs.js

@@ -34,6 +34,11 @@ export class ElevenLabsProvider {
         return this;
     }
 
+    v3() {
+        this.model_id = 'eleven_v3';
+        return this;
+    }    
+
     _getRequestOptions(voiceId, text, format) {
         return {
             method: "post",