@layercode/js-sdk 2.1.2 → 2.1.3

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

@@ -802,6 +802,8 @@ class AudioProcessor extends AudioWorkletProcessor {
     this.foundAudio = false;
     this.recording = false;
     this.chunks = [];
+    this.downsampleRatio = 1;
+    this.downsampleOffset = 0;
   }
 
   /**
@@ -908,9 +910,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;
@@ -933,6 +938,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);
@@ -985,14 +1008,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);
@@ -1038,10 +1087,13 @@ class WavRecorder {
     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 = {};
@@ -1250,20 +1302,53 @@ class WavRecorder {
    * @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;
@@ -1299,6 +1384,10 @@ class WavRecorder {
       }
       defaultDevice.default = true;
       deviceList.push(defaultDevice);
+    } else if (audioDevices.length) {
+      const fallbackDefault = audioDevices.shift();
+      fallbackDefault.default = true;
+      deviceList.push(fallbackDefault);
     }
     return deviceList.concat(audioDevices);
   }
@@ -1340,8 +1429,36 @@ class WavRecorder {
       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);
@@ -1377,6 +1494,14 @@ class WavRecorder {
       }
     };
 
+    processor.port.postMessage({
+      event: 'configure',
+      data: {
+        inputSampleRate: this.contextSampleRate,
+        targetSampleRate: this.sampleRate,
+      },
+    });
+
     const node = source.connect(processor);
     const analyser = context.createAnalyser();
     analyser.fftSize = 8192;
@@ -1392,6 +1517,15 @@ class WavRecorder {
       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;
@@ -1589,6 +1723,17 @@ class WavRecorder {
     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);
@@ -3509,7 +3654,7 @@ function arrayBufferToBase64(arrayBuffer) {
 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.
@@ -4010,7 +4155,7 @@ class LayercodeClient {
                 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) {
@@ -4047,7 +4192,7 @@ class LayercodeClient {
                 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) {