@tiledesk/tiledesk-voice-twilio-connector 0.1.28 → 0.2.0-rc3

package/src/services/AiService.sdk.js

@@ -0,0 +1,367 @@
+/**
+ * AiService.sdk.js - Alternative implementation using ElevenLabs SDK
+ * 
+ * This is a copy of AiService.js that uses the official ElevenLabs SDK
+ * instead of direct HTTP calls via axios.
+ * 
+ * To use this version:
+ * 1. Install the ElevenLabs SDK: npm install elevenlabs
+ * 2. Replace the import in your code to use this file instead
+ * 
+ * Note: This file maintains the same interface as AiService.js
+ * for backward compatibility.
+ */
+
+var winston = require('../utils/logger');
+const axios = require("axios").default;
+const FormData = require('form-data');
+
+/*ERROR HANDLER*/
+const { ServiceError } = require('../utils/errors');
+
+/*UTILS*/
+const fileUtils = require('../utils/fileUtils.js');
+
+// Try to import ElevenLabs SDK (will fail gracefully if not installed)
+let ElevenLabsClient;
+let ElevenLabs;
+try {
+  const elevenlabsModule = require('elevenlabs');
+  // The SDK exports ElevenLabsClient as a named export
+  ElevenLabsClient = elevenlabsModule.ElevenLabsClient || elevenlabsModule.default?.ElevenLabsClient;
+  ElevenLabs = elevenlabsModule;
+} catch (err) {
+  winston.warn('[AiService.sdk] ElevenLabs SDK not found. Install with: npm install elevenlabs');
+  ElevenLabsClient = null;
+  ElevenLabs = null;
+}
+
+class AiService {
+  
+  constructor(config) {
+    
+    if (!config) {
+      throw new Error("[AiService] config is mandatory");
+    }
+    if (!config.OPENAI_ENDPOINT) {
+      throw new Error("[AiService] config.OPENAI_ENDPOINT is mandatory");
+    }
+    if(!config.ELEVENLABS_ENDPOINT){
+      throw new Error("[AiService] config.ELEVENLABS_ENDPOINT is mandatory");
+    }
+    if (!config.API_URL) {
+      throw new Error("[AiService] config.API_URL is mandatory");
+    }
+    
+    this.OPENAI_ENDPOINT = config.OPENAI_ENDPOINT;
+    this.ELEVENLABS_ENDPOINT = config.ELEVENLABS_ENDPOINT;
+    this.API_URL = config.API_URL;
+    this.useSDK = config.useSDK !== false; // Default to true for SDK version
+    
+    // Check if SDK is available (we'll create client instances per-request with API keys)
+    this.sdkAvailable = false;
+    
+    if (this.useSDK && ElevenLabsClient) {
+      this.sdkAvailable = true;
+      winston.info('[AiService.sdk] ElevenLabs SDK available - will use SDK for ElevenLabs operations');
+    } else if (this.useSDK && !ElevenLabsClient) {
+      winston.warn('[AiService.sdk] ElevenLabs SDK not installed. Install with: npm install elevenlabs');
+      winston.warn('[AiService.sdk] Will use HTTP fallback for ElevenLabs operations');
+      this.sdkAvailable = false;
+    } else {
+      winston.info('[AiService.sdk] SDK usage disabled, will use HTTP for ElevenLabs operations');
+      this.sdkAvailable = false;
+    }
+  }
+  
+  async speechToText(fileUrl, model, GPT_KEY) {
+    let start_time = new Date(); 
+    winston.debug("[AiService] speechToText url: "+ fileUrl);   
+    
+    try {
+      let file;
+      try {
+        file = await fileUtils.downloadFromUrl(fileUrl);
+      } catch (err) {
+        winston.error("[AiService] err while downloadFromUrl: ", err);
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file:', fileUrl);
+      }
+      
+      if (!file) {
+        winston.debug('[AiService] OPENAI speechToText file NOT EXIST: . . . return');
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file: file is null');
+      }
+
+      const formData = new FormData();
+      formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
+      formData.append('model', model);
+
+      const resbody = await axios({
+        url: `${this.OPENAI_ENDPOINT}/audio/transcriptions`,
+        headers: {
+          ...formData.getHeaders(),
+          "Authorization": "Bearer " + GPT_KEY
+        },
+        data: formData,
+        method: 'POST'
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService] OpenAI speechToText time elapsed: ${end_time - start_time} ms`);
+      return resbody.data.text;
+
+    } catch (err) {
+      if (err instanceof ServiceError) throw err;
+      winston.error("[AiService] OpenAI STT error", err.message);
+      throw new ServiceError('AISERVICE_FAILED', 'OpenAI STT service failed with err:', err);
+    }
+  }
+  
+  async textToSpeech(text, name, model, GPT_KEY){
+    let start_time = new Date();
+    winston.debug('[AiService] textToSpeech text:'+ text)
+    
+    const data = {
+      model: model,
+      input: text,
+      voice: name,
+    };
+    
+    winston.debug('[AiService] textToSpeech config:', data)
+    
+    try {
+      const response = await axios({
+        url: `${this.OPENAI_ENDPOINT}/audio/speech`,
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": "Bearer " + GPT_KEY
+        },
+        responseType: 'arraybuffer',
+        data: data,
+        method: "POST",
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService] textToSpeech time elapsed: ${end_time - start_time} ms`);          
+      return response?.data;
+    } catch (err) {
+      winston.error("[AiService] textToSpeech error: ", err.response?.data);
+      throw new ServiceError('AISERVICE_FAILED', 'OpenAI textToSpeech API failed with err:', err);
+    }
+  }
+  
+  /**
+   * Speech-to-Text using ElevenLabs SDK
+   * Falls back to HTTP if SDK is not available or disabled
+   */
+  async speechToTextElevenLabs(fileUrl, model, language, API_KEY) {
+    let start_time = new Date();
+    winston.debug("[AiService.sdk] ELEVEN Labs speechToText url: "+ fileUrl);
+    
+    // If SDK is not available or disabled, fall back to HTTP
+    if (!this.useSDK || !this.sdkAvailable || !ElevenLabsClient) {
+      winston.debug("[AiService.sdk] SDK not available or disabled, using HTTP");
+      return this._speechToTextElevenLabsHTTP(fileUrl, model, language, API_KEY);
+    }
+    
+    try {
+      let file;
+      try {
+        file = await fileUtils.downloadFromUrl(fileUrl);
+      } catch (err) {
+        winston.error("[AiService.sdk] err: ", err);
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file:', fileUrl);
+      }
+      
+      if (!file) {
+        winston.debug('[AiService.sdk] ELEVEN Labs speechToText file NOT EXIST: . . . return');
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file: file is null');
+      }
+
+      // Use ElevenLabs SDK for STT
+      // Create a temporary client instance with the API key for this request
+      const client = new ElevenLabsClient({
+        apiKey: API_KEY
+      });
+      
+      // Use the convert method from the client
+      const transcription = await client.convert({
+        audio: file,
+        model_id: model || "scribe_v1",
+        language_code: language || "en"
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService.sdk] ELEVEN Labs speechToText (SDK) time elapsed: ${end_time - start_time} ms`);
+      
+      // SDK typically returns text directly or in a response object
+      return transcription.text || transcription;
+
+    } catch (err) {
+      winston.error("[AiService.sdk] ElevenLabs STT SDK error, falling back to HTTP:", err.message);
+      // Fallback to HTTP on SDK error
+      return this._speechToTextElevenLabsHTTP(fileUrl, model, language, API_KEY);
+    }
+  }
+
+  /**
+   * HTTP fallback for STT (original implementation)
+   */
+  async _speechToTextElevenLabsHTTP(fileUrl, model, language, API_KEY) {
+    let start_time = new Date();
+    winston.debug("[AiService.sdk] ELEVEN Labs speechToText (HTTP fallback) url: "+ fileUrl);
+    
+    try {
+      let file;
+      try {
+        file = await fileUtils.downloadFromUrl(fileUrl);
+      } catch (err) {
+        winston.error("[AiService.sdk] err: ", err);
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file:', fileUrl);
+      }
+      
+      if (!file) {
+        winston.debug('[AiService.sdk] ELEVEN Labs speechToText file NOT EXIST: . . . return');
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file: file is null');
+      }
+    
+      const formData = new FormData();
+      formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
+      formData.append('model_id', model || "scribe_v1");
+      formData.append('language_code', language || "en");
+
+      const resbody = await axios({
+        url: `${this.ELEVENLABS_ENDPOINT}/v1/speech-to-text`,
+        headers: {
+          ...formData.getHeaders(),
+          "xi-api-key": API_KEY
+        },
+        data: formData,
+        method: 'POST'
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService.sdk] ELEVEN Labs speechToText (HTTP) time elapsed: ${end_time - start_time} ms`);
+      return resbody.data.text;
+
+    } catch (err) {
+      if (err instanceof ServiceError) throw err;
+      winston.error("[AiService.sdk] ElevenLabs STT HTTP error", err.message);
+      throw new ServiceError('AISERVICE_FAILED', 'ElevenLabs STT service failed with err:', err);
+    }
+  }
+  
+  /**
+   * Text-to-Speech using ElevenLabs SDK
+   * Falls back to HTTP if SDK is not available or disabled
+   */
+  async textToSpeechElevenLabs(text, voice_id, model, language_code, API_KEY){
+    let start_time = new Date();
+    winston.debug('[AiService.sdk] ELEVEN Labs textToSpeech config:', { text, voice_id, model, language_code });
+    
+    // If SDK is not available or disabled, fall back to HTTP
+    if (!this.useSDK || !this.sdkAvailable || !ElevenLabsClient) {
+      winston.debug("[AiService.sdk] SDK not available or disabled, using HTTP");
+      return this._textToSpeechElevenLabsHTTP(text, voice_id, model, language_code, API_KEY);
+    }
+    
+    try {
+      // Use ElevenLabs SDK for TTS
+      // Create a temporary client instance with the API key for this request
+      const client = new ElevenLabsClient({
+        apiKey: API_KEY
+      });
+      
+      // Use the textToSpeech method from the client
+      const audio = await client.textToSpeech.convert(voice_id, {
+        text: text,
+        model_id: model || "eleven_multilingual_v2",
+        language_code: language_code || "en",
+        output_format: "mp3_44100_128" // Match original format
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService.sdk] ELEVEN Labs textToSpeech (SDK) time elapsed: ${end_time - start_time} ms`);
+      
+      // SDK typically returns audio buffer directly
+      // Convert to Buffer if needed
+      if (Buffer.isBuffer(audio)) {
+        return audio;
+      } else if (audio instanceof ArrayBuffer) {
+        return Buffer.from(audio);
+      } else if (typeof audio === 'string') {
+        // If base64, decode it
+        return Buffer.from(audio, 'base64');
+      } else {
+        // Try to get audio data from response object
+        return audio.data || audio.audio || audio;
+      }
+
+    } catch (err) {
+      winston.error("[AiService.sdk] ElevenLabs TTS SDK error, falling back to HTTP:", err.message);
+      // Fallback to HTTP on SDK error
+      return this._textToSpeechElevenLabsHTTP(text, voice_id, model, language_code, API_KEY);
+    }
+  }
+
+  /**
+   * HTTP fallback for TTS (original implementation)
+   */
+  async _textToSpeechElevenLabsHTTP(text, voice_id, model, language_code, API_KEY){
+    let start_time = new Date();
+    winston.debug('[AiService.sdk] ELEVEN Labs textToSpeech (HTTP fallback) config:', { text, voice_id, model, language_code });
+    
+    const data = {
+      model_id: model || "eleven_multilingual_v2",
+      text: text,
+      language_code: language_code || "en"
+    };
+    
+    try {
+      const response = await axios({
+        url: `${this.ELEVENLABS_ENDPOINT}/v1/text-to-speech/${voice_id}?output_format=mp3_44100_128`,
+        headers: {
+          "Content-Type": "application/json",
+          "xi-api-key": API_KEY
+        },
+        responseType: 'arraybuffer',
+        data: data,
+        method: "POST",
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService.sdk] ELEVEN Labs textToSpeech (HTTP) time elapsed: ${end_time - start_time} ms`);
+      return response?.data;
+    } catch (err) {
+      winston.error("[AiService.sdk] ELEVEN Labs textToSpeech HTTP error: ", err);
+      throw new ServiceError('AISERVICE_FAILED', 'ElevenLabs textToSpeech API failed with err:', err);
+    }
+  }
+  
+  async checkQuoteAvailability(projectId, token) {
+    winston.debug("[AiService] checkQuoteAvailability for project: "+ projectId);   
+          
+    try {
+      const resbody = await axios({
+        url: `${this.API_URL}/${projectId}/quotes/tokens`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': token
+        },
+        method: 'GET'
+      });
+
+      if (resbody && resbody.data?.isAvailable === true) {
+        return true;
+      } else {
+        return false;
+      }
+    } catch (err) {
+      winston.error("[AiService] checkQuoteAvailability error: ", err.response?.data);
+      throw new ServiceError('AISERVICE_FAILED', 'checkQuoteAvailability API failed with err:', err);
+    }
+  }
+}
+
+module.exports = { AiService };
+

package/src/services/IntegrationService.js

@@ -0,0 +1,74 @@
+const winston = require('../utils/logger');
+const axios = require("axios").default;
+
+class IntegrationService {
+  
+  constructor(config) {
+    
+    if (!config) {
+      throw new Error("[IntegrationService] config is mandatory");
+    }
+    if (!config.API_URL) {
+      throw new Error("[IntegrationService] config.API_URL is mandatory");
+    }
+
+    this.API_URL = config.API_URL;
+        
+  }
+
+  
+  async getKeyFromIntegrations(id_project, integration_name, token) {
+    winston.debug('[IntegrationService] getKeyFromIntegrations id_project:' + id_project + ' ' + integration_name)
+
+    try {
+      const response = await axios({
+        url: this.API_URL + "/" + id_project + "/integration/name/" + integration_name,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': token
+        },
+        data: {},
+        method: "GET",
+      });
+
+      if (!response.data || !response.data.value) {
+        return null;
+      }
+
+      return response.data.value.apikey;
+    } catch (err) {
+      winston.error("[IntegrationService] getKeyFromIntegrations error: ", err.response?.data || err.message);
+      return null;
+    }
+  }
+
+  async getKeyFromKbSettings(id_project, token) {
+    winston.debug('[IntegrationService] getKeyFromKbSettings id_project:', id_project)
+
+    try {
+      const response = await axios({
+        url: this.API_URL + "/" + id_project + "/kbsettings",
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': token
+        },
+        data: {},
+        method: "GET",
+      });
+
+      if (!response.data || !response.data.gptkey) {
+        return null;
+      }
+
+      return response.data.gptkey;
+    } catch (err) {
+      winston.error("[IntegrationService] getKeyFromKbSettings error: ", err.response?.data || err.message);
+      return null;
+    }
+  }
+  
+  
+  
+}
+
+module.exports = { IntegrationService };

package/src/services/MessageService.js

@@ -0,0 +1,133 @@
+const logger = require('../utils/logger');
+
+/**
+ * Service responsible for message queue operations and polling logic.
+ * Handles retrieving messages from queue with subscription fallback.
+ */
+class MessageService {
+  constructor({ voiceChannel, tdChannel, config }) {
+    if (!voiceChannel) throw new Error('[MessageService] voiceChannel is required');
+    if (!tdChannel) throw new Error('[MessageService] tdChannel is required');
+    if (!config) throw new Error('[MessageService] config is required');
+
+    this.voiceChannel = voiceChannel;
+    this.tdChannel = tdChannel;
+    this.maxPollingTime = config.MAX_POLLING_TIME || 5;
+  }
+
+  /**
+   * Get next message from queue with subscription fallback.
+   * If queue is empty, subscribes to topic and waits for message or timeout.
+   * 
+   * @param {string} callSid - The call session ID
+   * @param {string} conversationId - The conversation ID
+   * @param {string} ani - Caller phone number (for wait message)
+   * @returns {Promise<Object>} The message object
+   */
+  async getNextMessage(callSid, conversationId, ani) {
+    const startTime = Date.now();
+
+    try {
+      // 1. First attempt: read from queue
+      const queue = await this.tdChannel.getMessagesFromQueue(conversationId);
+      logger.debug(`[MessageService] Queue length: ${queue.length}`);
+
+      if (queue && queue.length > 0) {
+        return await this._processQueueMessage(callSid, conversationId, queue[0]);
+      }
+
+      // 2. Queue empty: subscribe with timeout
+      logger.debug('[MessageService] Queue empty, starting subscription...');
+      return await this._subscribeWithTimeout(callSid, conversationId, ani);
+
+    } catch (error) {
+      logger.error('[MessageService] getNextMessage error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Process a message from the queue.
+   */
+  async _processQueueMessage(callSid, conversationId, message) {
+    logger.verbose(`[MessageService] Processing queue message: ${message.text}`);
+
+    await this.tdChannel.removeMessageFromQueue(conversationId, message._id);
+    await this.voiceChannel.clearDelayTimeForCallId(callSid);
+
+    return message;
+  }
+
+  /**
+   * Subscribe to topic with timeout fallback.
+   * Returns message if received, or wait message if timeout.
+   */
+  async _subscribeWithTimeout(callSid, conversationId, ani) {
+    let timeoutId;
+
+    const subscriptionPromise = this._createSubscriptionPromise(callSid, conversationId, () => {
+      if (timeoutId) clearTimeout(timeoutId);
+    });
+
+    const timeoutPromise = this._createTimeoutPromise(callSid, ani, (id) => {
+      timeoutId = id;
+    });
+
+    return Promise.race([subscriptionPromise, timeoutPromise]);
+  }
+
+  /**
+   * Create promise that resolves when message received via subscription.
+   */
+  async _createSubscriptionPromise(callSid, conversationId, onSuccess) {
+    await this.tdChannel.subscribeToTopic(conversationId);
+    const queue = await this.tdChannel.getMessagesFromQueue(conversationId);
+
+    if (!queue || queue.length === 0) {
+      throw new Error('[MessageService] No message received after subscription');
+    }
+
+    const message = queue[0];
+    logger.verbose(`[MessageService] Message received from subscription: ${message.text}`);
+
+    await this.tdChannel.removeMessageFromQueue(conversationId, message._id);
+    await this.voiceChannel.clearDelayTimeForCallId(callSid);
+
+    onSuccess();
+    return message;
+  }
+
+  /**
+   * Create promise that resolves with wait message after timeout.
+   */
+  _createTimeoutPromise(callSid, ani, setTimeoutId) {
+    return new Promise((resolve) => {
+      const timeoutId = setTimeout(async () => {
+        logger.debug('[MessageService] Subscription timeout, generating wait message...');
+
+        const delayTime = await this.voiceChannel.getNextDelayTimeForCallId(callSid);
+        const waitMessage = await this.tdChannel.generateWaitTdMessage(ani, delayTime);
+        await this.voiceChannel.saveDelayIndexForCallId(callSid);
+
+        resolve(waitMessage);
+      }, this.maxPollingTime * 1000);
+
+      setTimeoutId(timeoutId);
+    });
+  }
+
+  /**
+   * Generate a wait message with appropriate delay.
+   * @param {string} callSid - The call session ID
+   * @param {string} ani - Caller identifier
+   * @returns {Promise<Object>} Wait message object
+   */
+  async generateWaitMessage(callSid, ani) {
+    const delayTime = await this.voiceChannel.getNextDelayTimeForCallId(callSid);
+    const waitMessage = await this.tdChannel.generateWaitTdMessage(ani, delayTime);
+    await this.voiceChannel.saveDelayIndexForCallId(callSid);
+    return waitMessage;
+  }
+}
+
+module.exports = { MessageService };

package/src/services/README_SDK.md

@@ -0,0 +1,107 @@
+# ElevenLabs SDK Implementation
+
+Questo documento descrive come usare l'implementazione dinamica che può utilizzare l'SDK ufficiale di ElevenLabs o le chiamate HTTP dirette, configurata tramite variabile d'ambiente.
+
+## Installazione
+
+Per usare l'SDK, installa il pacchetto ufficiale di ElevenLabs:
+
+```bash
+npm install elevenlabs
+```
+
+**Nota**: Se l'SDK non è installato, il sistema userà automaticamente le chiamate HTTP (fallback).
+
+## Configurazione
+
+Il sistema ora supporta l'uso dinamico dell'SDK tramite variabile d'ambiente. Non è più necessario modificare il codice!
+
+### Abilitare l'SDK
+
+Imposta la variabile d'ambiente `USE_ELEVENLABS_SDK`:
+
+```bash
+# Nel file .env
+USE_ELEVENLABS_SDK=true
+
+# Oppure quando avvii l'applicazione
+USE_ELEVENLABS_SDK=true npm start
+```
+
+### Disabilitare l'SDK (usare HTTP)
+
+```bash
+# Nel file .env
+USE_ELEVENLABS_SDK=false
+
+# Oppure ometti la variabile (default: HTTP)
+```
+
+## Come Funziona
+
+Il sistema ora carica dinamicamente l'implementazione corretta:
+
+1. **Con `USE_ELEVENLABS_SDK=true`**: 
+   - Usa `AiService.sdk.js` che tenta di utilizzare l'SDK
+   - Se l'SDK non è installato o fallisce, fa automaticamente fallback a HTTP
+   
+2. **Con `USE_ELEVENLABS_SDK=false` o non impostato**:
+   - Usa `AiService.js` con chiamate HTTP dirette (comportamento originale)
+
+Non è necessario modificare alcun file del codice!
+
+## Vantaggi dell'SDK
+
+1. **Gestione errori migliorata**: L'SDK gestisce automaticamente retry e error handling
+2. **Type safety**: Se usi TypeScript, l'SDK fornisce tipi
+3. **Aggiornamenti automatici**: L'SDK viene aggiornato con nuove funzionalità
+4. **Performance**: Possibili ottimizzazioni interne nell'SDK
+
+## Fallback automatico
+
+L'implementazione `AiService.sdk.js` include un fallback automatico:
+- Se l'SDK non è installato, usa le chiamate HTTP (comportamento originale)
+- Se l'SDK fallisce, ritorna automaticamente alle chiamate HTTP
+- Nessuna modifica al codice esistente è necessaria
+
+## Note sull'API dell'SDK
+
+L'SDK di ElevenLabs per Node.js potrebbe avere un'API leggermente diversa da quella documentata qui. 
+Verifica la documentazione ufficiale: https://elevenlabs.io/docs/api-reference
+
+Se l'API dell'SDK è diversa, modifica i metodi in `AiService.sdk.js`:
+- `speechToTextElevenLabs()` - per STT
+- `textToSpeechElevenLabs()` - per TTS
+
+## Testing
+
+Per testare l'implementazione SDK:
+
+1. Installa l'SDK: `npm install elevenlabs`
+2. Imposta `USE_ELEVENLABS_SDK=true` nel file `.env` o come variabile d'ambiente
+3. Esegui l'applicazione: `npm start`
+4. Verifica i log:
+   - Cerca `"Using ElevenLabs SDK implementation"` per confermare l'uso dell'SDK
+   - Cerca `"[AiService.sdk] ELEVEN Labs ... (SDK)"` per vedere le chiamate SDK
+   - Cerca `"[AiService.sdk] ... (HTTP)"` per vedere il fallback HTTP
+
+### Test con HTTP (comportamento originale)
+
+1. Imposta `USE_ELEVENLABS_SDK=false` o ometti la variabile
+2. Esegui l'applicazione
+3. Verifica i log: `"Using ElevenLabs HTTP implementation"`
+
+## Troubleshooting
+
+### SDK non trovato
+Se vedi il warning `ElevenLabs SDK not found`, installa il pacchetto:
+```bash
+npm install elevenlabs
+```
+
+### Errori nell'API dell'SDK
+Se l'SDK ha un'API diversa, modifica i metodi in `AiService.sdk.js` per corrispondere alla documentazione ufficiale dell'SDK.
+
+### Fallback a HTTP
+Se l'SDK fallisce, il sistema userà automaticamente le chiamate HTTP. Controlla i log per vedere quale metodo viene usato.
+