mini-chat-bot-widget 0.2.0 → 0.8.0

package/src/bhashiniApi.js

@@ -0,0 +1,363 @@
+export class BhashiniFrontend {
+    constructor() {
+      this.apiKey = '23588533c1-d990-4a7d-b052-d970c886147e';
+      this.userId = '749bd0b0c65e4d17a372be0ad92af981';
+      this.callbackUrl = 'https://meity-auth.ulcacontrib.org/ulca/apis/v0/model/getModelsPipeline';
+      this.inferenceUrl = null;
+      this.inferenceHeaders = {};
+      this.asrServiceId = {
+        'hi': 'ai4bharat/conformer-hi-gpu--t4',
+        'en': 'ai4bharat/whisper-medium-en--gpu--t4'
+      };
+      this.ttsServiceId = {
+        'hi': 'ai4bharat/indic-tts-coqui-indo_aryan-gpu--t4',
+        'en': 'ai4bharat/indic-tts-coqui-misc-gpu--t4'
+      };
+      this.translationServiceId = 'ai4bharat/indictrans-v2-all-gpu--t4';
+    }
+  
+    async initialize() {
+      try {
+        const response = await fetch(this.callbackUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'userID': this.userId,
+            'ulcaApiKey': this.apiKey
+          },
+          body: JSON.stringify({
+            pipelineTasks: [{ taskType: 'asr' }],
+            pipelineRequestConfig: {
+              pipelineId: '64392f96daac500b55c543cd'
+            }
+          })
+        });
+  
+        const data = await response.json();
+        
+        if (data.pipelineInferenceAPIEndPoint) {
+          this.inferenceUrl = data.pipelineInferenceAPIEndPoint.callbackUrl;
+          const keyName = data.pipelineInferenceAPIEndPoint.inferenceApiKey.name;
+          const keyValue = data.pipelineInferenceAPIEndPoint.inferenceApiKey.value;
+          this.inferenceHeaders = {
+            'Content-Type': 'application/json',
+            [keyName]: keyValue
+          };
+        } else {
+          // Fallback to direct endpoint
+          this.inferenceUrl = 'https://dhruva-api.bhashini.gov.in/services/inference/pipeline';
+          this.inferenceHeaders = {
+            'Content-Type': 'application/json',
+            'userID': this.userId,
+            'ulcaApiKey': this.apiKey
+          };
+        }
+        
+        return true;
+      } catch (error) {
+        console.error('Failed to initialize Bhashini:', error);
+        // Use fallback endpoint
+        this.inferenceUrl = 'https://dhruva-api.bhashini.gov.in/services/inference/pipeline';
+        this.inferenceHeaders = {
+          'Content-Type': 'application/json',
+          'userID': this.userId,
+          'ulcaApiKey': this.apiKey
+        };
+        return false;
+      }
+    }
+  
+    async convertToWav(audioBlob) {
+      return new Promise((resolve, reject) => {
+        const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+        const reader = new FileReader();
+        
+        reader.onload = async (e) => {
+          try {
+            const arrayBuffer = e.target.result;
+            const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+            
+            // Convert to mono 16kHz
+            const offlineContext = new OfflineAudioContext(1, audioBuffer.duration * 16000, 16000);
+            const source = offlineContext.createBufferSource();
+            source.buffer = audioBuffer;
+            source.connect(offlineContext.destination);
+            source.start();
+            
+            const renderedBuffer = await offlineContext.startRendering();
+            
+            // Convert to WAV
+            const wav = this.audioBufferToWav(renderedBuffer);
+            const wavBlob = new Blob([wav], { type: 'audio/wav' });
+            
+            // Convert to base64
+            const wavReader = new FileReader();
+            wavReader.onloadend = () => {
+              const base64 = wavReader.result.split(',')[1];
+              resolve(base64);
+            };
+            wavReader.readAsDataURL(wavBlob);
+          } catch (error) {
+            reject(error);
+          }
+        };
+        
+        reader.onerror = reject;
+        reader.readAsArrayBuffer(audioBlob);
+      });
+    }
+  
+    audioBufferToWav(buffer) {
+      const length = buffer.length * buffer.numberOfChannels * 2 + 44;
+      const arrayBuffer = new ArrayBuffer(length);
+      const view = new DataView(arrayBuffer);
+      const channels = [];
+      let offset = 0;
+      let pos = 0;
+  
+      // Write WAV header
+      const setUint16 = (data) => {
+        view.setUint16(pos, data, true);
+        pos += 2;
+      };
+      const setUint32 = (data) => {
+        view.setUint32(pos, data, true);
+        pos += 4;
+      };
+  
+      // "RIFF" chunk descriptor
+      setUint32(0x46464952); // "RIFF"
+      setUint32(length - 8); // file length - 8
+      setUint32(0x45564157); // "WAVE"
+  
+      // "fmt " sub-chunk
+      setUint32(0x20746d66); // "fmt "
+      setUint32(16); // SubChunk1Size = 16
+      setUint16(1); // AudioFormat = 1 (PCM)
+      setUint16(buffer.numberOfChannels);
+      setUint32(buffer.sampleRate);
+      setUint32(buffer.sampleRate * 2 * buffer.numberOfChannels); // byte rate
+      setUint16(buffer.numberOfChannels * 2); // block align
+      setUint16(16); // bits per sample
+  
+      // "data" sub-chunk
+      setUint32(0x61746164); // "data"
+      setUint32(length - pos - 4); // SubChunk2Size
+  
+      // Write interleaved data
+      for (let i = 0; i < buffer.numberOfChannels; i++) {
+        channels.push(buffer.getChannelData(i));
+      }
+  
+      while (pos < length) {
+        for (let i = 0; i < buffer.numberOfChannels; i++) {
+          let sample = Math.max(-1, Math.min(1, channels[i][offset]));
+          sample = sample < 0 ? sample * 0x8000 : sample * 0x7FFF;
+          view.setInt16(pos, sample, true);
+          pos += 2;
+        }
+        offset++;
+      }
+  
+      return arrayBuffer;
+    }
+  
+async speechToText(
+  base64Audio,
+  sourceLanguage = 'auto',
+  targetLanguage = 'hi'
+) {
+  if (!this.inferenceUrl) {
+    await this.initialize();
+  }
+
+  const pipelineTasks = [
+    {
+      taskType: 'asr',
+      config: {
+        language: { sourceLanguage },
+        serviceId:
+          this.asrServiceId[sourceLanguage] ||
+          this.asrServiceId['hi'],
+        audioFormat: 'wav',
+        samplingRate: 16000
+      }
+    }
+  ];
+
+  // Only translate if languages differ
+  if (sourceLanguage !== targetLanguage) {
+    pipelineTasks.push({
+      taskType: 'translation',
+      config: {
+        sourceLanguage:
+          sourceLanguage === 'auto' ? undefined : sourceLanguage,
+        targetLanguage
+      }
+    });
+  }
+
+  const response = await fetch(this.inferenceUrl, {
+    method: 'POST',
+    headers: this.inferenceHeaders,
+    body: JSON.stringify({
+      pipelineTasks,
+      inputData: {
+        audio: [{ audioContent: base64Audio }]
+      }
+    })
+  });
+
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status} ${response.statusText}`);
+  }
+
+  const data = await response.json();
+
+  // If translated, return translation
+  if (pipelineTasks.length > 1) {
+    return data.pipelineResponse[1].output[0].target;
+  }
+
+  // Otherwise return raw transcription
+  return data.pipelineResponse[0].output[0].source;
+}
+
+  
+async textToSpeech(text, language = 'en', gender = 'female') {
+  if (!this.inferenceUrl) {
+    await this.initialize();
+  }
+
+  // ✅ Clean the text first
+  const cleanedText = text.replace(/!/g, ".");
+
+  const response = await fetch(this.inferenceUrl, {
+    method: 'POST',
+    headers: this.inferenceHeaders,
+    body: JSON.stringify({
+      pipelineTasks: [
+        {
+          taskType: "tts",
+          config: {
+            language: { sourceLanguage: language },
+            serviceId: this.ttsServiceId[language] || this.ttsServiceId["en"],
+            samplingRate: 8000,
+            gender: gender,
+          },
+        },
+      ],
+      inputData: {
+        input: [{ source: cleanedText }],
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`TTS API error: ${response.status} ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  return data.pipelineResponse[0].audio[0].audioContent;
+}
+
+  
+    async translateText(text, sourceLanguage, targetLanguage) {
+      if (!this.inferenceUrl) {
+        await this.initialize();
+      }
+  
+      const response = await fetch(this.inferenceUrl, {
+        method: 'POST',
+        headers: this.inferenceHeaders,
+        body: JSON.stringify({
+          pipelineTasks: [{
+            taskType: 'translation',
+            config: {
+              language: {
+                sourceLanguage: sourceLanguage,
+                targetLanguage: targetLanguage
+              },
+              serviceId: this.translationServiceId
+            }
+          }],
+          inputData: {
+            input: [{ source: text }]
+          }
+        })
+      });
+  
+      if (!response.ok) {
+        throw new Error(`Translation API error: ${response.status} ${response.statusText}`);
+      }
+  
+      const data = await response.json();
+      return data.pipelineResponse[0].output[0].target;
+    }
+  
+    async speechToEnglish(base64Audio, sourceLanguage = 'hi') {
+      // Step 1: Transcribe audio to source language text
+      const transcribedText = await this.speechToText(base64Audio, sourceLanguage);
+      
+      // Step 2: If already English, return as is
+      if (sourceLanguage === 'en') {
+        return { transcription: transcribedText, translation: transcribedText };
+      }
+      
+      // Step 3: Translate to English
+      const translatedText = await this.translateText(transcribedText, sourceLanguage, 'en');
+      
+      return {
+        transcription: transcribedText,
+        translation: translatedText
+      };
+    }
+  
+    async speechToHindi(base64Audio, sourceLanguage = 'en') {
+      // Step 1: Transcribe audio to source language text
+      const transcribedText = await this.speechToText(base64Audio, sourceLanguage);
+      
+      // Step 2: If already Hindi, return as is
+      if (sourceLanguage === 'hi') {
+        return { transcription: transcribedText, translation: transcribedText };
+      }
+      
+      // Step 3: Translate to Hindi
+      const translatedText = await this.translateText(transcribedText, sourceLanguage, 'hi');
+      
+      return {
+        transcription: transcribedText,
+        translation: translatedText
+      };
+    }
+    
+    
+    async transcribeSpeechToEnglish(base64Audio, sourceLanguage = "hi") {
+      // Step 1: Transcribe audio to source language text
+      const transcribedText = await this.speechToText(
+          base64Audio,
+          sourceLanguage,
+      );
+
+      // Step 2: If already English, return as is
+      if (sourceLanguage === "en") {
+          return {
+              transcription: transcribedText,
+              translation: transcribedText,
+          };
+      }
+
+      // Step 3: Translate to English
+      const translatedText = await this.translateText(
+          transcribedText,
+          sourceLanguage,
+          "en",
+      );
+
+      return {
+          transcription: transcribedText,
+          translation: translatedText,
+      };
+  }
+    
+  }