@layercode/js-sdk 2.1.2 → 2.1.3

package/dist/layercode-js-sdk.min.js

@@ -808,6 +808,8 @@ class AudioProcessor extends AudioWorkletProcessor {
     this.foundAudio = false;
     this.recording = false;
     this.chunks = [];
+    this.downsampleRatio = 1;
+    this.downsampleOffset = 0;
   }
 
   /**
@@ -914,9 +916,12 @@ class AudioProcessor extends AudioWorkletProcessor {
   }
 
   receive(e) {
-    const { event, id } = e.data;
+    const { event, id, data } = e.data;
     let receiptData = {};
     switch (event) {
+      case 'configure':
+        this.configure(data);
+        return;
       case 'start':
         this.recording = true;
         break;
@@ -939,6 +944,24 @@ class AudioProcessor extends AudioWorkletProcessor {
     this.port.postMessage({ event: 'receipt', id, data: receiptData });
   }
 
+  configure(config = {}) {
+    const inputSampleRate = config?.inputSampleRate;
+    const targetSampleRate = config?.targetSampleRate;
+    if (
+      typeof inputSampleRate === 'number' &&
+      inputSampleRate > 0 &&
+      typeof targetSampleRate === 'number' &&
+      targetSampleRate > 0
+    ) {
+      if (inputSampleRate <= targetSampleRate) {
+        this.downsampleRatio = 1;
+      } else {
+        this.downsampleRatio = inputSampleRate / targetSampleRate;
+      }
+      this.downsampleOffset = 0;
+    }
+  }
+
   sendChunk(chunk) {
     const channels = this.readChannelData([chunk]);
     const { float32Array, meanValues } = this.formatAudioData(channels);
@@ -991,14 +1014,40 @@ class AudioProcessor extends AudioWorkletProcessor {
       }
     }
     if (inputs && inputs[0] && this.foundAudio && this.recording) {
-      // We need to copy the TypedArray, because the \`process\`
+      // We need to copy the TypedArray, because the  \`process\`
       // internals will reuse the same buffer to hold each input
       const chunk = inputs.map((input) => input.slice(sliceIndex));
-      this.chunks.push(chunk);
-      this.sendChunk(chunk);
+      const processedChunk = this.downsampleChunk(chunk);
+      if (processedChunk[0] && processedChunk[0].length) {
+        this.chunks.push(processedChunk);
+        this.sendChunk(processedChunk);
+      }
     }
     return true;
   }
+
+  downsampleChunk(chunk) {
+    if (this.downsampleRatio === 1) {
+      return chunk;
+    }
+    const channelCount = chunk.length;
+    if (!channelCount || !chunk[0]?.length) {
+      return chunk;
+    }
+    const ratio = this.downsampleRatio;
+    const inputLength = chunk[0].length;
+    const outputs = Array.from({ length: channelCount }, () => []);
+    let offset = this.downsampleOffset;
+    while (offset < inputLength) {
+      const sampleIndex = Math.floor(offset);
+      for (let c = 0; c < channelCount; c++) {
+        outputs[c].push(chunk[c][sampleIndex]);
+      }
+      offset += ratio;
+    }
+    this.downsampleOffset = offset - inputLength;
+    return outputs.map((samples) => Float32Array.from(samples));
+  }
 }
 
 registerProcessor('audio_processor', AudioProcessor);
@@ -1044,10 +1093,13 @@ registerProcessor('audio_processor', AudioProcessor);
       this._devices = [];
       // State variables
       this.stream = null;
+      this.audioContext = null;
       this.processor = null;
       this.source = null;
       this.node = null;
+      this.analyser = null;
       this.recording = false;
+      this.contextSampleRate = sampleRate;
       // Event handling with AudioWorklet
       this._lastEventId = 0;
       this.eventReceipts = {};
@@ -1256,20 +1308,53 @@ registerProcessor('audio_processor', AudioProcessor);
      * @returns {Promise<true>}
      */
     async requestPermission() {
-      const permissionStatus = await navigator.permissions.query({
-        name: 'microphone',
-      });
-      if (permissionStatus.state === 'denied') {
-        window.alert('You must grant microphone access to use this feature.');
-      } else if (permissionStatus.state === 'prompt') {
+      const ensureUserMediaAccess = async () => {
+        const stream = await navigator.mediaDevices.getUserMedia({
+          audio: true,
+        });
+        const tracks = stream.getTracks();
+        tracks.forEach((track) => track.stop());
+      };
+
+      const permissionsUnsupported =
+        !navigator.permissions ||
+        typeof navigator.permissions.query !== 'function';
+
+      if (permissionsUnsupported) {
         try {
-          const stream = await navigator.mediaDevices.getUserMedia({
-            audio: true,
-          });
-          const tracks = stream.getTracks();
-          tracks.forEach((track) => track.stop());
-        } catch (e) {
+          await ensureUserMediaAccess();
+        } catch (error) {
+          window.alert('You must grant microphone access to use this feature.');
+          throw error;
+        }
+        return true;
+      }
+
+      try {
+        const permissionStatus = await navigator.permissions.query({
+          name: 'microphone',
+        });
+
+        if (permissionStatus.state === 'denied') {
+          window.alert('You must grant microphone access to use this feature.');
+          return true;
+        }
+
+        if (permissionStatus.state === 'prompt') {
+          try {
+            await ensureUserMediaAccess();
+          } catch (error) {
+            window.alert('You must grant microphone access to use this feature.');
+            throw error;
+          }
+        }
+      } catch (error) {
+        // Firefox rejects permissions.query with NotSupportedError – fall back to getUserMedia directly
+        try {
+          await ensureUserMediaAccess();
+        } catch (fallbackError) {
           window.alert('You must grant microphone access to use this feature.');
+          throw fallbackError;
         }
       }
       return true;
@@ -1305,6 +1390,10 @@ registerProcessor('audio_processor', AudioProcessor);
         }
         defaultDevice.default = true;
         deviceList.push(defaultDevice);
+      } else if (audioDevices.length) {
+        const fallbackDefault = audioDevices.shift();
+        fallbackDefault.default = true;
+        deviceList.push(fallbackDefault);
       }
       return deviceList.concat(audioDevices);
     }
@@ -1346,8 +1435,36 @@ registerProcessor('audio_processor', AudioProcessor);
         throw new Error('Could not start media stream');
       }
 
-      const context = new AudioContext({ sampleRate: this.sampleRate });
-      const source = context.createMediaStreamSource(this.stream);
+      const createContext = (rate) => {
+        try {
+          return rate ? new AudioContext({ sampleRate: rate }) : new AudioContext();
+        } catch (error) {
+          console.warn('Failed to create AudioContext with sampleRate', rate, error);
+          return null;
+        }
+      };
+
+      let context = createContext(this.sampleRate);
+      if (!context) {
+        context = createContext();
+      }
+      if (!context) {
+        throw new Error('Could not create AudioContext');
+      }
+
+      let source;
+      try {
+        source = context.createMediaStreamSource(this.stream);
+      } catch (error) {
+        await context.close().catch(() => {});
+        context = createContext();
+        if (!context) {
+          throw error;
+        }
+        source = context.createMediaStreamSource(this.stream);
+      }
+
+      this.contextSampleRate = context.sampleRate;
       // Load and execute the module script.
       try {
         await context.audioWorklet.addModule(this.scriptSrc);
@@ -1383,6 +1500,14 @@ registerProcessor('audio_processor', AudioProcessor);
         }
       };
 
+      processor.port.postMessage({
+        event: 'configure',
+        data: {
+          inputSampleRate: this.contextSampleRate,
+          targetSampleRate: this.sampleRate,
+        },
+      });
+
       const node = source.connect(processor);
       const analyser = context.createAnalyser();
       analyser.fftSize = 8192;
@@ -1398,6 +1523,15 @@ registerProcessor('audio_processor', AudioProcessor);
         analyser.connect(context.destination);
       }
 
+      if (context.state === 'suspended') {
+        try {
+          await context.resume();
+        } catch (resumeError) {
+          console.warn('AudioContext resume failed', resumeError);
+        }
+      }
+
+      this.audioContext = context;
       this.source = source;
       this.node = node;
       this.analyser = analyser;
@@ -1595,6 +1729,17 @@ registerProcessor('audio_processor', AudioProcessor);
       this.processor = null;
       this.source = null;
       this.node = null;
+      this.analyser = null;
+
+      if (this.audioContext) {
+        try {
+          await this.audioContext.close();
+        } catch (contextError) {
+          console.warn('Failed to close AudioContext', contextError);
+        }
+        this.audioContext = null;
+      }
+      this.contextSampleRate = null;
 
       const packer = new WavPacker();
       const result = packer.pack(this.sampleRate, exportData.audio);
@@ -3515,7 +3660,7 @@ registerProcessor('audio_processor', AudioProcessor);
   const NOOP = () => { };
   const DEFAULT_WS_URL = 'wss://api.layercode.com/v1/agents/web/websocket';
   // SDK version - updated when publishing
-  const SDK_VERSION = '2.1.2';
+  const SDK_VERSION = '2.1.3';
   /**
    * @class LayercodeClient
    * @classdesc Core client for Layercode audio agent that manages audio recording, WebSocket communication, and speech processing.
@@ -4016,7 +4161,7 @@ registerProcessor('audio_processor', AudioProcessor);
                   const newStream = this.wavRecorder.getStream();
                   await this._reinitializeVAD(newStream);
               }
-              const reportedDeviceId = (_c = (_b = this.lastReportedDeviceId) !== null && _b !== void 0 ? _b : this.activeDeviceId) !== null && _c !== void 0 ? _c : (this.useSystemDefaultDevice ? 'default' : (normalizedDeviceId !== null && normalizedDeviceId !== void 0 ? normalizedDeviceId : 'default'));
+              const reportedDeviceId = (_c = (_b = this.lastReportedDeviceId) !== null && _b !== void 0 ? _b : this.activeDeviceId) !== null && _c !== void 0 ? _c : (this.useSystemDefaultDevice ? 'default' : normalizedDeviceId !== null && normalizedDeviceId !== void 0 ? normalizedDeviceId : 'default');
               console.debug(`Successfully switched to input device: ${reportedDeviceId}`);
           }
           catch (error) {
@@ -4053,7 +4198,7 @@ registerProcessor('audio_processor', AudioProcessor);
                   this.recorderStarted = true;
                   this._sendReadyIfNeeded();
               }
-              const reportedDeviceId = (_a = this.activeDeviceId) !== null && _a !== void 0 ? _a : (this.useSystemDefaultDevice ? 'default' : ((_b = this.deviceId) !== null && _b !== void 0 ? _b : 'default'));
+              const reportedDeviceId = (_a = this.activeDeviceId) !== null && _a !== void 0 ? _a : (this.useSystemDefaultDevice ? 'default' : (_b = this.deviceId) !== null && _b !== void 0 ? _b : 'default');
               if (reportedDeviceId !== previousReportedDeviceId) {
                   this.lastReportedDeviceId = reportedDeviceId;
                   if (this.options.onDeviceSwitched) {