@modochats/widget 0.1.0

package/src/utils/fetch.ts

@@ -0,0 +1,98 @@
+import {$fetch} from "#src/tools/fetch.js";
+import {FetchPaginationRes} from "#src/types/app.js";
+
+const fetchChatbot = async (publicKey: string) => {
+  return await $fetch<Record<string, any>>(`/v1/chatbot/public/${publicKey}`);
+};
+
+const fetchSendMessage = async (
+  chatbotId: number,
+  content: string,
+  uniqueId: string,
+  conversationUuid?: string,
+  phoneNumber?: string,
+  options?: {
+    file?: File;
+    replyTo?: number;
+  }
+) => {
+  const formData = new FormData();
+  formData.append("chatbot_id", chatbotId.toString());
+  formData.append("content", content);
+  formData.append("message_type", "0");
+  formData.append("unique_id", uniqueId);
+  if (conversationUuid) formData.append("conversation_id", conversationUuid);
+  formData.append("url", window?.location?.href || "");
+  formData.append("title", document?.title || "");
+  if (phoneNumber && phoneNumber !== "no phone number") formData.append("phone_number", phoneNumber);
+  if (options?.file) formData.append("file", options.file);
+  if (options?.replyTo) formData.append("response_to", options.replyTo.toString());
+
+  return await $fetch("/v2/conversations/website/send-message/", {
+    method: "POST",
+    body: formData
+  });
+};
+const fetchGetAccessTokenForSocket = async (chatbotId: string, conversationUuid: string, uniqueId: string) => {
+  return await $fetch<{access_token: string; conversation_uuid: string; expires_in: number}>("/v2/conversations/websocket/auth/", {
+    method: "POST",
+    body: {
+      chatbot_id: chatbotId,
+      conversation_uuid: conversationUuid,
+      unique_id: uniqueId
+    }
+  });
+};
+const fetchConversationMessages = async (conversationUuid: string, chatbotUuid: string) => {
+  return await $fetch<Record<string, any>>(`/v2/conversations/website/conversations/${conversationUuid}/chatbot/${chatbotUuid}/messages/`);
+};
+const fetchUpdateUserData = async (chatbotUuid: string, uniqueId: string, userData: Record<string, any>) => {
+  return await $fetch("/v1/chatbot/customners/set-user-data", {
+    method: "POST",
+    body: {
+      chatbot_uuid: chatbotUuid,
+      unique_id: uniqueId,
+      user_data: userData
+    }
+  });
+};
+const fetchReadMessage = async (id: number) => {
+  return await $fetch(`/v2/conversations/messages/${id}/`, {
+    method: "POST"
+  });
+};
+const fetchMarkConversationAsRead = async (conversationUuid: string, uniqueId: string) => {
+  return await $fetch(`/v2/conversations/website/conversations/${conversationUuid}/messages/seen`, {
+    method: "POST",
+    body: {
+      unique_id: uniqueId
+    }
+  });
+};
+
+const fetchMessageFeedback = async (id: number, uniqueId: string, conversationUuid: string, liked: boolean) => {
+  return await $fetch(`/v2/conversations/website/conversations/messages/feedback`, {
+    method: "POST",
+    body: {
+      unique_id: uniqueId,
+      feedback: liked ? 1 : 0,
+      message_id: id,
+      conversation_uuid: conversationUuid
+    }
+  });
+};
+
+const fetchConversations = async (conversationUuid: string, uniqueId: string) => {
+  return await $fetch<FetchPaginationRes>(`/v2/conversations/website/conversations/${conversationUuid}/customer/${uniqueId}`);
+};
+export {
+  fetchChatbot,
+  fetchSendMessage,
+  fetchGetAccessTokenForSocket,
+  fetchConversationMessages,
+  fetchUpdateUserData,
+  fetchReadMessage,
+  fetchMarkConversationAsRead,
+  fetchMessageFeedback,
+  fetchConversations
+};

package/src/utils/uuid.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates a random UUID v4
+ * @returns A random UUID string
+ */
+const generateUUID = (): string => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+export {generateUUID};

package/temp/audio-processor.js

@@ -0,0 +1,261 @@
+class AudioProcessor extends AudioWorkletProcessor {
+    constructor() {
+        super();
+        this.bufferSize = 4096;
+        this.buffer = new Float32Array(this.bufferSize);
+        this.bufferIndex = 0;
+        
+        this.noiseThreshold = 0.01;
+        this.voiceThreshold = 0.08;
+        this.silenceFrames = 0;
+        this.maxSilenceFrames = 8;
+        this.isVoiceActive = false;
+        this.isPaused = false;
+        
+        this.noiseProfile = new Float32Array(128).fill(0);
+        this.noiseProfileIndex = 0;
+        this.noiseProfileReady = false;
+        
+        this.previousSamples = new Float32Array(this.bufferSize).fill(0);
+        
+        this.preRollBuffer = [];
+        this.maxPreRollBuffers = 5;
+        
+        this.tailBuffer = [];
+        this.maxTailBuffers = 3;
+        this.sendingTail = false;
+        
+        this.justResumed = false;
+        this.resumedFrameCount = 0;
+        this.resumedFrameThreshold = 150;
+        
+        this.port.onmessage = (event) => {
+            if (event.data.type === 'set-voice-threshold') {
+                this.voiceThreshold = event.data.value;
+            } else if (event.data.type === 'set-noise-threshold') {
+                this.noiseThreshold = event.data.value;
+            } else if (event.data.type === 'pause') {
+                this.isPaused = true;
+                console.log('AudioProcessor: Input paused');
+            } else if (event.data.type === 'resume') {
+                this.isPaused = false;
+                // Reset VAD state when resuming but KEEP pre-roll buffer
+                this.isVoiceActive = false;
+                this.silenceFrames = 0;
+                // Reset noise profile to quickly adapt to new environment
+                this.noiseProfile.fill(0);
+                this.noiseProfileIndex = 0;
+                this.noiseProfileReady = false;
+                // Be extra sensitive for the first ~1 second after resume
+                this.justResumed = true;
+                this.resumedFrameCount = 0;
+                // Don't clear preRollBuffer - it may contain the start of speech
+                console.log('AudioProcessor: Input resumed - VAD and noise profile reset, sensitivity boosted');
+            }
+        };
+    }
+    
+    calculateRMS(samples) {
+        let sum = 0;
+        for (let i = 0; i < samples.length; i++) {
+            sum += samples[i] * samples[i];
+        }
+        return Math.sqrt(sum / samples.length);
+    }
+    
+    calculateDB(rms) {
+        if (rms <= 0 || isNaN(rms)) return -Infinity;
+        const db = 20 * Math.log10(rms);
+        return isNaN(db) ? -Infinity : db;
+    }
+    
+    updateNoiseProfile(samples) {
+        const rms = this.calculateRMS(samples);
+        this.noiseProfile[this.noiseProfileIndex] = rms;
+        this.noiseProfileIndex = (this.noiseProfileIndex + 1) % this.noiseProfile.length;
+        
+        if (this.noiseProfileIndex === 0) {
+            this.noiseProfileReady = true;
+        }
+    }
+    
+    getNoiseFloor() {
+        if (!this.noiseProfileReady) {
+            return this.noiseThreshold;
+        }
+        
+        const sorted = Array.from(this.noiseProfile).sort((a, b) => a - b);
+        return sorted[Math.floor(sorted.length * 0.25)];
+    }
+    
+    applySpectralSubtraction(samples) {
+        const output = new Float32Array(samples.length);
+        const noiseFloor = this.getNoiseFloor();
+        
+        for (let i = 0; i < samples.length; i++) {
+            const signal = Math.abs(samples[i]);
+            
+            if (signal < noiseFloor * 2) {
+                output[i] = 0;
+            } else {
+                const cleaned = signal - noiseFloor;
+                output[i] = samples[i] >= 0 ? cleaned : -cleaned;
+            }
+        }
+        
+        return output;
+    }
+    
+    applyHighPassFilter(samples) {
+        const output = new Float32Array(samples.length);
+        const alpha = 0.95;
+        
+        output[0] = samples[0];
+        for (let i = 1; i < samples.length; i++) {
+            output[i] = alpha * (output[i-1] + samples[i] - this.previousSamples[i]);
+        }
+        
+        this.previousSamples.set(samples);
+        return output;
+    }
+    
+    applyNoiseGate(samples, rms) {
+        const noiseFloor = this.getNoiseFloor();
+        let adaptiveThreshold = Math.max(this.noiseThreshold, noiseFloor * 1.8);
+        
+        if (this.justResumed) {
+            adaptiveThreshold = adaptiveThreshold * 0.3;
+        }
+        
+        if (rms < adaptiveThreshold) {
+            return new Float32Array(samples.length);
+        }
+        
+        return samples;
+    }
+    
+    detectVoice(rms) {
+        const noiseFloor = this.getNoiseFloor();
+        
+        let adaptiveVoiceThreshold;
+        if (this.justResumed) {
+            this.resumedFrameCount++;
+            
+            const boostProgress = Math.min(this.resumedFrameCount / this.resumedFrameThreshold, 1.0);
+            const boostMultiplier = 0.2 + (0.8 * boostProgress);
+            
+            adaptiveVoiceThreshold = this.voiceThreshold * boostMultiplier;
+            
+            if (this.resumedFrameCount % 20 === 0) {
+                console.log(`AudioProcessor: Boosted threshold: ${adaptiveVoiceThreshold.toFixed(4)} (${(boostMultiplier * 100).toFixed(0)}% of normal, RMS: ${rms.toFixed(4)})`);
+            }
+            
+            if (this.resumedFrameCount > this.resumedFrameThreshold) {
+                this.justResumed = false;
+                console.log('AudioProcessor: Sensitivity boost ended, returning to adaptive threshold');
+            }
+        } else {
+            const multiplier = 1.8;
+            adaptiveVoiceThreshold = Math.max(this.voiceThreshold, noiseFloor * multiplier);
+        }
+        
+        const wasActive = this.isVoiceActive;
+        
+        if (rms > adaptiveVoiceThreshold) {
+            if (!this.isVoiceActive) {
+                this.isVoiceActive = true;
+                if (this.justResumed) {
+                    console.log('AudioProcessor: Voice detected with boost!');
+                }
+                return { justActivated: true, isActive: true };
+            }
+            this.isVoiceActive = true;
+            this.silenceFrames = 0;
+        } else if (this.isVoiceActive) {
+            this.silenceFrames++;
+            if (this.silenceFrames > this.maxSilenceFrames) {
+                this.isVoiceActive = false;
+                this.sendingTail = true;
+                this.preRollBuffer = [];
+                return { justActivated: false, isActive: false, justDeactivated: true };
+            }
+        } else {
+            this.updateNoiseProfile(this.buffer);
+        }
+        
+        return { justActivated: false, isActive: this.isVoiceActive, justDeactivated: false };
+    }
+    
+    process(inputs, outputs, parameters) {
+        const input = inputs[0];
+        if (input.length > 0) {
+            const inputChannel = input[0];
+            
+            for (let i = 0; i < inputChannel.length; i++) {
+                this.buffer[this.bufferIndex] = inputChannel[i];
+                this.bufferIndex++;
+                
+                if (this.bufferIndex >= this.bufferSize) {
+                    const rms = this.calculateRMS(this.buffer);
+                    const db = this.calculateDB(rms);
+                    const voiceStatus = this.detectVoice(rms);
+                    
+                    this.port.postMessage({
+                        type: 'voice-level',
+                        rms: rms,
+                        db: db,
+                        isActive: voiceStatus.isActive,
+                        noiseFloor: this.getNoiseFloor(),
+                        isPaused: this.isPaused
+                    });
+                    
+                    if (!this.isPaused) {
+                        let processedBuffer = this.buffer;
+                        
+                        const int16Buffer = new Int16Array(this.bufferSize);
+                        for (let j = 0; j < this.bufferSize; j++) {
+                            const s = Math.max(-1, Math.min(1, processedBuffer[j]));
+                            int16Buffer[j] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+                        }
+                        
+                        if (voiceStatus.justActivated && this.preRollBuffer.length > 0) {
+                            for (const preRollBuffer of this.preRollBuffer) {
+                                this.port.postMessage(preRollBuffer);
+                            }
+                            this.preRollBuffer = [];
+                            this.tailBuffer = [];
+                            this.sendingTail = false;
+                        }
+                        
+                        if (voiceStatus.isActive) {
+                            this.port.postMessage(int16Buffer.buffer);
+                            this.tailBuffer = [];
+                            this.sendingTail = false;
+                        } else if (this.sendingTail) {
+                            this.tailBuffer.push(int16Buffer.buffer);
+                            if (this.tailBuffer.length >= this.maxTailBuffers) {
+                                for (const tailBuffer of this.tailBuffer) {
+                                    this.port.postMessage(tailBuffer);
+                                }
+                                this.port.postMessage({ type: 'voice-ended' });
+                                this.tailBuffer = [];
+                                this.sendingTail = false;
+                            }
+                        } else {
+                            this.preRollBuffer.push(int16Buffer.buffer);
+                            if (this.preRollBuffer.length > this.maxPreRollBuffers) {
+                                this.preRollBuffer.shift();
+                            }
+                        }
+                    }
+                    
+                    this.bufferIndex = 0;
+                }
+            }
+        }
+        
+        return true;
+    }
+}
+
+registerProcessor('audio-processor', AudioProcessor);