@layercode/js-sdk 2.1.5 → 2.1.7

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

@@ -4,21 +4,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.LayercodeClient = factory());
 })(this, (function () { 'use strict';
 
-  function _mergeNamespaces(n, m) {
-    m.forEach(function (e) {
-      e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-        if (k !== 'default' && !(k in n)) {
-          var d = Object.getOwnPropertyDescriptor(e, k);
-          Object.defineProperty(n, k, d.get ? d : {
-            enumerable: true,
-            get: function () { return e[k]; }
-          });
-        }
-      });
-    });
-    return Object.freeze(n);
-  }
-
   /**
    * Raw wav audio file contents
    * @typedef {Object} WavPackerAudioType
@@ -1324,54 +1309,14 @@ registerProcessor('audio_processor', AudioProcessor);
      * @returns {Promise<true>}
      */
     async requestPermission() {
-      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 {
-          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',
+        console.log('ensureUserMediaAccess');
+        await navigator.mediaDevices.getUserMedia({
+          audio: true,
         });
-
-        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;
-        }
+      } catch (fallbackError) {
+        window.alert('You must grant microphone access to use this feature.');
+        throw fallbackError;
       }
       return true;
     }
@@ -1388,10 +1333,9 @@ registerProcessor('audio_processor', AudioProcessor);
         throw new Error('Could not request user devices');
       }
       await this.requestPermission();
+
       const devices = await navigator.mediaDevices.enumerateDevices();
-      const audioDevices = devices.filter(
-        (device) => device.kind === 'audioinput',
-      );
+      const audioDevices = devices.filter((device) => device.kind === 'audioinput');
       const defaultDeviceIndex = audioDevices.findIndex(
         (device) => device.deviceId === 'default',
       );
@@ -1779,1777 +1723,1033 @@ registerProcessor('audio_processor', AudioProcessor);
 
   globalThis.WavRecorder = WavRecorder;
 
-  /**
-   * Converts a base64 string to an ArrayBuffer.
-   * @param {string} base64 - The base64 string to convert.
-   * @returns {ArrayBuffer} The resulting ArrayBuffer.
-   */
-  function base64ToArrayBuffer(base64) {
-    const binaryString = atob(base64);
-    const len = binaryString.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes.buffer;
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  function getAugmentedNamespace(n) {
+    if (n.__esModule) return n;
+    var f = n.default;
+  	if (typeof f == "function") {
+  		var a = function a () {
+  			if (this instanceof a) {
+          return Reflect.construct(f, arguments, this.constructor);
+  			}
+  			return f.apply(this, arguments);
+  		};
+  		a.prototype = f.prototype;
+    } else a = {};
+    Object.defineProperty(a, '__esModule', {value: true});
+  	Object.keys(n).forEach(function (k) {
+  		var d = Object.getOwnPropertyDescriptor(n, k);
+  		Object.defineProperty(a, k, d.get ? d : {
+  			enumerable: true,
+  			get: function () {
+  				return n[k];
+  			}
+  		});
+  	});
+  	return a;
   }
 
-  /**
-   * Converts an ArrayBuffer to a base64 string.
-   * @param {ArrayBuffer|Float32Array|Int16Array} arrayBuffer - The ArrayBuffer to convert.
-   * @returns {string} The resulting base64 string.
-   */
-  function arrayBufferToBase64$1(arrayBuffer) {
-    if (arrayBuffer instanceof Float32Array) {
-      arrayBuffer = this.floatTo16BitPCM(arrayBuffer);
-    } else if (arrayBuffer instanceof Int16Array) {
-      arrayBuffer = arrayBuffer.buffer;
-    }
-    let binary = '';
-    let bytes = new Uint8Array(arrayBuffer);
-    const chunkSize = 0x8000; // 32KB chunk size
-    for (let i = 0; i < bytes.length; i += chunkSize) {
-      let chunk = bytes.subarray(i, i + chunkSize);
-      binary += String.fromCharCode.apply(null, chunk);
-    }
-    return btoa(binary);
+  var dist = {};
+
+  var assetPath = {};
+
+  Object.defineProperty(assetPath, "__esModule", { value: true });
+  assetPath.baseAssetPath = void 0;
+  // nextjs@14 bundler may attempt to execute this during SSR and crash
+  const isWeb = typeof window !== "undefined" && typeof window.document !== "undefined";
+  const currentScript = isWeb
+      ? window.document.currentScript
+      : null;
+  let basePath = "/";
+  if (currentScript) {
+      basePath = currentScript.src
+          .replace(/#.*$/, "")
+          .replace(/\?.*$/, "")
+          .replace(/\/[^\/]+$/, "/");
   }
+  assetPath.baseAssetPath = basePath;
 
-  /* eslint-env browser */
-  // import { env as ortEnv } from 'onnxruntime-web';
-  const NOOP = () => { };
-  const DEFAULT_WS_URL = 'wss://api.layercode.com/v1/agents/web/websocket';
-  // SDK version - updated when publishing
-  const SDK_VERSION = '2.1.3';
-  // Lazily load the browser-only VAD module to avoid accessing `self` on the server
-  let micVADModulePromise = null;
-  const loadMicVADModule = () => {
-      if (typeof window === 'undefined') {
-          return Promise.resolve(null);
+  var defaultModelFetcher$1 = {};
+
+  Object.defineProperty(defaultModelFetcher$1, "__esModule", { value: true });
+  defaultModelFetcher$1.defaultModelFetcher = void 0;
+  const defaultModelFetcher = (path) => {
+      return fetch(path).then((model) => model.arrayBuffer());
+  };
+  defaultModelFetcher$1.defaultModelFetcher = defaultModelFetcher;
+
+  var frameProcessor = {};
+
+  var logging = {};
+
+  (function (exports) {
+  	Object.defineProperty(exports, "__esModule", { value: true });
+  	exports.log = exports.LOG_PREFIX = void 0;
+  	exports.LOG_PREFIX = "[VAD]";
+  	const levels = ["error", "debug", "warn"];
+  	function getLog(level) {
+  	    return (...args) => {
+  	        console[level](exports.LOG_PREFIX, ...args);
+  	    };
+  	}
+  	const _log = levels.reduce((acc, level) => {
+  	    acc[level] = getLog(level);
+  	    return acc;
+  	}, {});
+  	exports.log = _log;
+  	
+  } (logging));
+
+  var messages = {};
+
+  Object.defineProperty(messages, "__esModule", { value: true });
+  messages.Message = void 0;
+  var Message;
+  (function (Message) {
+      Message["AudioFrame"] = "AUDIO_FRAME";
+      Message["SpeechStart"] = "SPEECH_START";
+      Message["VADMisfire"] = "VAD_MISFIRE";
+      Message["SpeechEnd"] = "SPEECH_END";
+      Message["SpeechStop"] = "SPEECH_STOP";
+      Message["SpeechRealStart"] = "SPEECH_REAL_START";
+      Message["FrameProcessed"] = "FRAME_PROCESSED";
+  })(Message || (messages.Message = Message = {}));
+
+  /*
+  Some of this code, together with the default options found in index.ts,
+  were taken (or took inspiration) from https://github.com/snakers4/silero-vad
+  */
+  Object.defineProperty(frameProcessor, "__esModule", { value: true });
+  frameProcessor.FrameProcessor = frameProcessor.validateOptions = frameProcessor.defaultV5FrameProcessorOptions = frameProcessor.defaultLegacyFrameProcessorOptions = void 0;
+  const logging_1$3 = logging;
+  const messages_1 = messages;
+  const RECOMMENDED_FRAME_SAMPLES = [512, 1024, 1536];
+  frameProcessor.defaultLegacyFrameProcessorOptions = {
+      positiveSpeechThreshold: 0.5,
+      negativeSpeechThreshold: 0.5 - 0.15,
+      preSpeechPadFrames: 1,
+      redemptionFrames: 8,
+      frameSamples: 1536,
+      minSpeechFrames: 3,
+      submitUserSpeechOnPause: false,
+  };
+  frameProcessor.defaultV5FrameProcessorOptions = {
+      positiveSpeechThreshold: 0.5,
+      negativeSpeechThreshold: 0.5 - 0.15,
+      preSpeechPadFrames: 3,
+      redemptionFrames: 24,
+      frameSamples: 512,
+      minSpeechFrames: 9,
+      submitUserSpeechOnPause: false,
+  };
+  function validateOptions(options) {
+      if (!RECOMMENDED_FRAME_SAMPLES.includes(options.frameSamples)) {
+          logging_1$3.log.warn("You are using an unusual frame size");
+      }
+      if (options.positiveSpeechThreshold < 0 ||
+          options.positiveSpeechThreshold > 1) {
+          logging_1$3.log.error("positiveSpeechThreshold should be a number between 0 and 1");
+      }
+      if (options.negativeSpeechThreshold < 0 ||
+          options.negativeSpeechThreshold > options.positiveSpeechThreshold) {
+          logging_1$3.log.error("negativeSpeechThreshold should be between 0 and positiveSpeechThreshold");
+      }
+      if (options.preSpeechPadFrames < 0) {
+          logging_1$3.log.error("preSpeechPadFrames should be positive");
       }
-      if (!micVADModulePromise) {
-          // @ts-ignore - VAD package does not provide TypeScript types
-          micVADModulePromise = Promise.resolve().then(function () { return index$1; });
+      if (options.redemptionFrames < 0) {
+          logging_1$3.log.error("redemptionFrames should be positive");
       }
-      return micVADModulePromise;
+  }
+  frameProcessor.validateOptions = validateOptions;
+  const concatArrays = (arrays) => {
+      const sizes = arrays.reduce((out, next) => {
+          out.push(out.at(-1) + next.length);
+          return out;
+      }, [0]);
+      const outArray = new Float32Array(sizes.at(-1));
+      arrays.forEach((arr, index) => {
+          const place = sizes[index];
+          outArray.set(arr, place);
+      });
+      return outArray;
   };
-  /**
-   * @class LayercodeClient
-   * @classdesc Core client for Layercode audio agent that manages audio recording, WebSocket communication, and speech processing.
-   */
-  class LayercodeClient {
-      /**
-       * Creates an instance of LayercodeClient.
-       * @param {Object} options - Configuration options
-       */
-      constructor(options) {
-          var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
-          this.deviceId = null;
-          this.options = {
-              agentId: options.agentId,
-              conversationId: (_a = options.conversationId) !== null && _a !== void 0 ? _a : null,
-              authorizeSessionEndpoint: options.authorizeSessionEndpoint,
-              metadata: (_b = options.metadata) !== null && _b !== void 0 ? _b : {},
-              vadResumeDelay: (_c = options.vadResumeDelay) !== null && _c !== void 0 ? _c : 500,
-              onConnect: (_d = options.onConnect) !== null && _d !== void 0 ? _d : NOOP,
-              onDisconnect: (_e = options.onDisconnect) !== null && _e !== void 0 ? _e : NOOP,
-              onError: (_f = options.onError) !== null && _f !== void 0 ? _f : NOOP,
-              onDeviceSwitched: (_g = options.onDeviceSwitched) !== null && _g !== void 0 ? _g : NOOP,
-              onDataMessage: (_h = options.onDataMessage) !== null && _h !== void 0 ? _h : NOOP,
-              onMessage: (_j = options.onMessage) !== null && _j !== void 0 ? _j : NOOP,
-              onUserAmplitudeChange: (_k = options.onUserAmplitudeChange) !== null && _k !== void 0 ? _k : NOOP,
-              onAgentAmplitudeChange: (_l = options.onAgentAmplitudeChange) !== null && _l !== void 0 ? _l : NOOP,
-              onStatusChange: (_m = options.onStatusChange) !== null && _m !== void 0 ? _m : NOOP,
-              onUserIsSpeakingChange: (_o = options.onUserIsSpeakingChange) !== null && _o !== void 0 ? _o : NOOP,
-              onMuteStateChange: (_p = options.onMuteStateChange) !== null && _p !== void 0 ? _p : NOOP,
+  class FrameProcessor {
+      constructor(modelProcessFunc, modelResetFunc, options) {
+          this.modelProcessFunc = modelProcessFunc;
+          this.modelResetFunc = modelResetFunc;
+          this.options = options;
+          this.speaking = false;
+          this.redemptionCounter = 0;
+          this.speechFrameCount = 0;
+          this.active = false;
+          this.speechRealStartFired = false;
+          this.reset = () => {
+              this.speaking = false;
+              this.speechRealStartFired = false;
+              this.audioBuffer = [];
+              this.modelResetFunc();
+              this.redemptionCounter = 0;
+              this.speechFrameCount = 0;
+          };
+          this.pause = (handleEvent) => {
+              this.active = false;
+              if (this.options.submitUserSpeechOnPause) {
+                  this.endSegment(handleEvent);
+              }
+              else {
+                  this.reset();
+              }
+          };
+          this.resume = () => {
+              this.active = true;
+          };
+          this.endSegment = (handleEvent) => {
+              const audioBuffer = this.audioBuffer;
+              this.audioBuffer = [];
+              const speaking = this.speaking;
+              this.reset();
+              if (speaking) {
+                  const speechFrameCount = audioBuffer.reduce((acc, item) => {
+                      return item.isSpeech ? (acc + 1) : acc;
+                  }, 0);
+                  if (speechFrameCount >= this.options.minSpeechFrames) {
+                      const audio = concatArrays(audioBuffer.map((item) => item.frame));
+                      handleEvent({ msg: messages_1.Message.SpeechEnd, audio });
+                  }
+                  else {
+                      handleEvent({ msg: messages_1.Message.VADMisfire });
+                  }
+              }
+              return {};
+          };
+          this.process = async (frame, handleEvent) => {
+              if (!this.active) {
+                  return;
+              }
+              const probs = await this.modelProcessFunc(frame);
+              const isSpeech = probs.isSpeech >= this.options.positiveSpeechThreshold;
+              handleEvent({ probs, msg: messages_1.Message.FrameProcessed, frame });
+              this.audioBuffer.push({
+                  frame,
+                  isSpeech,
+              });
+              if (isSpeech) {
+                  this.speechFrameCount++;
+                  this.redemptionCounter = 0;
+              }
+              if (isSpeech && !this.speaking) {
+                  this.speaking = true;
+                  handleEvent({ msg: messages_1.Message.SpeechStart });
+              }
+              if (this.speaking &&
+                  this.speechFrameCount === this.options.minSpeechFrames &&
+                  !this.speechRealStartFired) {
+                  this.speechRealStartFired = true;
+                  handleEvent({ msg: messages_1.Message.SpeechRealStart });
+              }
+              if (probs.isSpeech < this.options.negativeSpeechThreshold &&
+                  this.speaking &&
+                  ++this.redemptionCounter >= this.options.redemptionFrames) {
+                  this.redemptionCounter = 0;
+                  this.speechFrameCount = 0;
+                  this.speaking = false;
+                  this.speechRealStartFired = false;
+                  const audioBuffer = this.audioBuffer;
+                  this.audioBuffer = [];
+                  const speechFrameCount = audioBuffer.reduce((acc, item) => {
+                      return item.isSpeech ? (acc + 1) : acc;
+                  }, 0);
+                  if (speechFrameCount >= this.options.minSpeechFrames) {
+                      const audio = concatArrays(audioBuffer.map((item) => item.frame));
+                      handleEvent({ msg: messages_1.Message.SpeechEnd, audio });
+                  }
+                  else {
+                      handleEvent({ msg: messages_1.Message.VADMisfire });
+                  }
+              }
+              if (!this.speaking) {
+                  while (this.audioBuffer.length > this.options.preSpeechPadFrames) {
+                      this.audioBuffer.shift();
+                  }
+                  this.speechFrameCount = 0;
+              }
           };
-          this.AMPLITUDE_MONITORING_SAMPLE_RATE = 2;
-          this._websocketUrl = DEFAULT_WS_URL;
-          this.wavRecorder = new WavRecorder({ sampleRate: 8000 }); // TODO should be set my fetched agent config
-          this.wavPlayer = new WavStreamPlayer({
-              finishedPlayingCallback: this._clientResponseAudioReplayFinished.bind(this),
-              sampleRate: 16000, // TODO should be set my fetched agent config
-          });
-          this.vad = null;
-          this.ws = null;
-          this.status = 'disconnected';
-          this.userAudioAmplitude = 0;
-          this.agentAudioAmplitude = 0;
-          this.conversationId = this.options.conversationId;
-          this.pushToTalkActive = false;
-          this.pushToTalkEnabled = false;
-          this.canInterrupt = false;
-          this.userIsSpeaking = false;
-          this.recorderStarted = false;
-          this.readySent = false;
-          this.currentTurnId = null;
           this.audioBuffer = [];
-          this.vadConfig = null;
-          this.activeDeviceId = null;
-          this.useSystemDefaultDevice = false;
-          this.lastReportedDeviceId = null;
-          this.lastKnownSystemDefaultDeviceKey = null;
-          this.isMuted = false;
-          this.stopPlayerAmplitude = undefined;
-          this.stopRecorderAmplitude = undefined;
-          this.deviceChangeListener = null;
-          // this.audioPauseTime = null;
-          // Bind event handlers
-          this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
-          this._handleDataAvailable = this._handleDataAvailable.bind(this);
+          this.reset();
       }
-      _initializeVAD() {
-          var _a;
-          if (typeof window === 'undefined') {
-              return;
-          }
-          console.log('initializing VAD', { pushToTalkEnabled: this.pushToTalkEnabled, canInterrupt: this.canInterrupt, vadConfig: this.vadConfig });
-          // If we're in push to talk mode, we don't need to use the VAD model
-          if (this.pushToTalkEnabled) {
-              return;
+  }
+  frameProcessor.FrameProcessor = FrameProcessor;
+
+  var nonRealTimeVad = {};
+
+  var ortWeb_min = {exports: {}};
+
+  // Copyright (c) Microsoft Corporation. All rights reserved.
+  // Licensed under the MIT License.
+  const backends = {};
+  const backendsSortedByPriority = [];
+  /**
+   * Register a backend.
+   *
+   * @param name - the name as a key to lookup as an execution provider.
+   * @param backend - the backend object.
+   * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority
+   * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.
+   *
+   * @internal
+   */
+  const registerBackend = (name, backend, priority) => {
+      if (backend && typeof backend.init === 'function' && typeof backend.createSessionHandler === 'function') {
+          const currentBackend = backends[name];
+          if (currentBackend === undefined) {
+              backends[name] = { backend, priority };
           }
-          // Check if VAD is disabled
-          if (((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) === false) {
-              console.log('VAD is disabled by backend configuration');
+          else if (currentBackend.priority > priority) {
+              // same name is already registered with a higher priority. skip registeration.
               return;
           }
-          // Build VAD configuration object, only including keys that are defined
-          const vadOptions = {
-              stream: this.wavRecorder.getStream() || undefined,
-              onSpeechStart: () => {
-                  console.debug('onSpeechStart: sending vad_start');
-                  this.userIsSpeaking = true;
-                  this.options.onUserIsSpeakingChange(true);
-                  this._wsSend({
-                      type: 'vad_events',
-                      event: 'vad_start',
-                  });
-                  this.options.onMessage({
-                      type: 'vad_events',
-                      event: 'vad_start',
-                  });
-              },
-              onSpeechEnd: () => {
-                  console.debug('onSpeechEnd: sending vad_end');
-                  this.userIsSpeaking = false;
-                  this.options.onUserIsSpeakingChange(false);
-                  this.audioBuffer = []; // Clear buffer on speech end
-                  this._wsSend({
-                      type: 'vad_events',
-                      event: 'vad_end',
-                  });
-                  this.options.onMessage({
-                      type: 'vad_events',
-                      event: 'vad_end',
-                  });
-              },
-          };
-          // Apply VAD configuration from backend if available
-          if (this.vadConfig) {
-              // Only add keys that are explicitly defined (not undefined)
-              if (this.vadConfig.model !== undefined)
-                  vadOptions.model = this.vadConfig.model;
-              if (this.vadConfig.positive_speech_threshold !== undefined)
-                  vadOptions.positiveSpeechThreshold = this.vadConfig.positive_speech_threshold;
-              if (this.vadConfig.negative_speech_threshold !== undefined)
-                  vadOptions.negativeSpeechThreshold = this.vadConfig.negative_speech_threshold;
-              if (this.vadConfig.redemption_frames !== undefined)
-                  vadOptions.redemptionFrames = this.vadConfig.redemption_frames;
-              if (this.vadConfig.min_speech_frames !== undefined)
-                  vadOptions.minSpeechFrames = this.vadConfig.min_speech_frames;
-              if (this.vadConfig.pre_speech_pad_frames !== undefined)
-                  vadOptions.preSpeechPadFrames = this.vadConfig.pre_speech_pad_frames;
-              if (this.vadConfig.frame_samples !== undefined)
-                  vadOptions.frameSamples = this.vadConfig.frame_samples;
-          }
-          else {
-              // Default values if no config from backend
-              vadOptions.model = 'v5';
-              vadOptions.positiveSpeechThreshold = 0.15;
-              vadOptions.negativeSpeechThreshold = 0.05;
-              vadOptions.redemptionFrames = 4;
-              vadOptions.minSpeechFrames = 2;
-              vadOptions.preSpeechPadFrames = 0;
-              vadOptions.frameSamples = 512; // Required for v5
+          else if (currentBackend.priority === priority) {
+              if (currentBackend.backend !== backend) {
+                  throw new Error(`cannot register backend "${name}" using priority ${priority}`);
+              }
           }
-          console.log('Creating VAD with options:', vadOptions);
-          loadMicVADModule()
-              .then((module) => { var _a, _b, _c; return (_c = (_b = (_a = module === null || module === void 0 ? void 0 : module.MicVAD) === null || _a === void 0 ? void 0 : _a.new) === null || _b === void 0 ? void 0 : _b.call(_a, vadOptions)) !== null && _c !== void 0 ? _c : null; })
-              .then((vad) => {
-              if (!vad) {
-                  throw new Error('MicVAD module not available');
+          if (priority >= 0) {
+              const i = backendsSortedByPriority.indexOf(name);
+              if (i !== -1) {
+                  backendsSortedByPriority.splice(i, 1);
               }
-              this.vad = vad;
-              this.vad.start();
-              console.log('VAD started successfully');
-          })
-              .catch((error) => {
-              console.warn('Error initializing VAD:', error);
-              // Send a message to server indicating VAD failure
-              this._wsSend({
-                  type: 'vad_events',
-                  event: 'vad_model_failed',
-              });
-          });
-      }
-      /**
-       * Updates the connection status and triggers the callback
-       * @param {string} status - New status value
-       */
-      _setStatus(status) {
-          this.status = status;
-          this.options.onStatusChange(status);
+              for (let i = 0; i < backendsSortedByPriority.length; i++) {
+                  if (backends[backendsSortedByPriority[i]].priority <= priority) {
+                      backendsSortedByPriority.splice(i, 0, name);
+                      return;
+                  }
+              }
+              backendsSortedByPriority.push(name);
+          }
+          return;
       }
-      /**
-       * Handles when agent audio finishes playing
-       */
-      _clientResponseAudioReplayFinished() {
-          console.debug('clientResponseAudioReplayFinished');
-          this._wsSend({
-              type: 'trigger.response.audio.replay_finished',
-              reason: 'completed',
-          });
-      }
-      async _clientInterruptAssistantReplay() {
-          await this.wavPlayer.interrupt();
-      }
-      async triggerUserTurnStarted() {
-          if (!this.pushToTalkActive) {
-              this.pushToTalkActive = true;
-              this._wsSend({ type: 'trigger.turn.start', role: 'user' });
-              await this._clientInterruptAssistantReplay();
-          }
-      }
-      async triggerUserTurnFinished() {
-          if (this.pushToTalkActive) {
-              this.pushToTalkActive = false;
-              this._wsSend({ type: 'trigger.turn.end', role: 'user' });
-          }
-      }
-      /**
-       * Handles incoming WebSocket messages
-       * @param {MessageEvent} event - The WebSocket message event
-       */
-      async _handleWebSocketMessage(event) {
-          try {
-              const message = JSON.parse(event.data);
-              if (message.type !== 'response.audio') {
-                  console.debug('msg:', message);
-              }
-              switch (message.type) {
-                  case 'turn.start':
-                      // Sent from the server to this client when a new user turn is detected
-                      if (message.role === 'assistant') {
-                          // Start tracking new assistant turn
-                          console.debug('Assistant turn started, will track new turn ID from audio/text');
-                      }
-                      else if (message.role === 'user' && !this.pushToTalkEnabled) {
-                          // Interrupt any playing assistant audio if this is a turn triggered by the server (and not push to talk, which will have already called interrupt)
-                          console.debug('interrupting assistant audio, as user turn has started and pushToTalkEnabled is false');
-                          await this._clientInterruptAssistantReplay();
-                      }
-                      this.options.onMessage(message);
-                      break;
-                  case 'response.audio':
-                      const audioBuffer = base64ToArrayBuffer(message.content);
-                      this.wavPlayer.add16BitPCM(audioBuffer, message.turn_id);
-                      // TODO: once we've added turn_id to the turn.start msgs sent from teh server, we should move this currentTurnId switching logic to the turn.start msg case. We can then remove the currentTurnId setting logic from the response.audio and response.text cases.
-                      // Set current turn ID from first audio message, or update if different turn
-                      if (!this.currentTurnId || this.currentTurnId !== message.turn_id) {
-                          console.debug(`Setting current turn ID to: ${message.turn_id} (was: ${this.currentTurnId})`);
-                          this.currentTurnId = message.turn_id;
-                          // Clean up interrupted tracks, keeping only the current turn
-                          this.wavPlayer.clearInterruptedTracks(this.currentTurnId ? [this.currentTurnId] : []);
-                      }
-                      break;
-                  case 'response.text':
-                      // Set turn ID from first text message if not set
-                      if (!this.currentTurnId) {
-                          this.currentTurnId = message.turn_id;
-                          console.debug(`Setting current turn ID to: ${message.turn_id} from text message`);
-                      }
-                      this.options.onMessage(message);
-                      break;
-                  case 'response.data':
-                      this.options.onDataMessage(message);
-                      break;
-                  case 'user.transcript':
-                  case 'user.transcript.delta':
-                  case 'user.transcript.interim_delta':
-                      this.options.onMessage(message);
-                      break;
-                  default:
-                      console.warn('Unknown message type received:', message);
-              }
-          }
-          catch (error) {
-              console.error('Error processing WebSocket message:', error);
-              this.options.onError(error instanceof Error ? error : new Error(String(error)));
-          }
-      }
-      /**
-       * Handles available client browser microphone audio data and sends it over the WebSocket
-       * @param {ArrayBuffer} data - The audio data buffer
-       */
-      _handleDataAvailable(data) {
-          var _a, _b, _c;
-          try {
-              const base64 = arrayBufferToBase64$1(data.mono);
-              // Don't send audio if muted
-              if (this.isMuted) {
-                  return;
-              }
-              // Determine if we should gate audio based on VAD configuration
-              const shouldGateAudio = ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.gate_audio) !== false; // Default to true if not specified
-              const bufferFrames = (_c = (_b = this.vadConfig) === null || _b === void 0 ? void 0 : _b.buffer_frames) !== null && _c !== void 0 ? _c : 10; // Default to 10 if not specified
-              let sendAudio;
-              if (this.pushToTalkEnabled) {
-                  sendAudio = this.pushToTalkActive;
-              }
-              else if (shouldGateAudio) {
-                  sendAudio = this.userIsSpeaking;
+      throw new TypeError('not a valid backend');
+  };
+  /**
+   * Resolve backend by specified hints.
+   *
+   * @param backendHints - a list of execution provider names to lookup. If omitted use registered backends as list.
+   * @returns a promise that resolves to the backend.
+   *
+   * @internal
+   */
+  const resolveBackend = async (backendHints) => {
+      const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;
+      const errors = [];
+      for (const backendName of backendNames) {
+          const backendInfo = backends[backendName];
+          if (backendInfo) {
+              if (backendInfo.initialized) {
+                  return backendInfo.backend;
               }
-              else {
-                  // If gate_audio is false, always send audio
-                  sendAudio = true;
+              else if (backendInfo.aborted) {
+                  continue; // current backend is unavailable; try next
               }
-              if (sendAudio) {
-                  // If we have buffered audio and we're gating, send it first
-                  if (shouldGateAudio && this.audioBuffer.length > 0) {
-                      console.debug(`Sending ${this.audioBuffer.length} buffered audio chunks`);
-                      for (const bufferedAudio of this.audioBuffer) {
-                          this._wsSend({
-                              type: 'client.audio',
-                              content: bufferedAudio,
-                          });
-                      }
-                      this.audioBuffer = []; // Clear the buffer after sending
+              const isInitializing = !!backendInfo.initPromise;
+              try {
+                  if (!isInitializing) {
+                      backendInfo.initPromise = backendInfo.backend.init();
                   }
-                  // Send the current audio
-                  this._wsSend({
-                      type: 'client.audio',
-                      content: base64,
-                  });
+                  await backendInfo.initPromise;
+                  backendInfo.initialized = true;
+                  return backendInfo.backend;
               }
-              else {
-                  // Buffer audio when not sending (to catch audio just before VAD triggers)
-                  this.audioBuffer.push(base64);
-                  // Keep buffer size based on configuration
-                  if (this.audioBuffer.length > bufferFrames) {
-                      this.audioBuffer.shift(); // Remove oldest chunk
+              catch (e) {
+                  if (!isInitializing) {
+                      errors.push({ name: backendName, err: e });
                   }
+                  backendInfo.aborted = true;
+              }
+              finally {
+                  delete backendInfo.initPromise;
               }
-          }
-          catch (error) {
-              console.error('Error processing audio:', error);
-              this.options.onError(error instanceof Error ? error : new Error(String(error)));
-          }
-      }
-      _wsSend(message) {
-          var _a;
-          if (message.type !== 'client.audio') {
-              console.debug('sent_msg:', message);
-          }
-          const messageString = JSON.stringify(message);
-          if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
-              this.ws.send(messageString);
           }
       }
-      _sendReadyIfNeeded() {
-          var _a;
-          if (this.recorderStarted && ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN && !this.readySent) {
-              this._wsSend({ type: 'client.ready' });
-              this.readySent = true;
-          }
+      throw new Error(`no available backend found. ERR: ${errors.map(e => `[${e.name}] ${e.err}`).join(', ')}`);
+  };
+
+  // Copyright (c) Microsoft Corporation. All rights reserved.
+  // Licensed under the MIT License.
+  class EnvImpl {
+      constructor() {
+          this.wasm = {};
+          this.webgl = {};
+          this.logLevelInternal = 'warning';
       }
-      /**
-       * Sets up amplitude monitoring for a given audio source.
-       * @param {WavRecorder | WavStreamPlayer} source - The audio source (recorder or player).
-       * @param {(amplitude: number) => void} callback - The callback function to invoke on amplitude change.
-       * @param {(amplitude: number) => void} updateInternalState - Function to update the internal amplitude state.
-       */
-      _setupAmplitudeMonitoring(source, callback, updateInternalState) {
-          let updateCounter = 0;
-          source.startAmplitudeMonitoring((amplitude) => {
-              // Only update and call callback at the specified sample rate
-              if (updateCounter >= this.AMPLITUDE_MONITORING_SAMPLE_RATE) {
-                  updateInternalState(amplitude);
-                  if (callback !== NOOP) {
-                      callback(amplitude);
-                  }
-                  updateCounter = 0; // Reset counter after sampling
-              }
-              updateCounter++;
-          });
-          const stop = () => { var _a; return (_a = source.stopAmplitudeMonitoring) === null || _a === void 0 ? void 0 : _a.call(source); };
-          if (source === this.wavPlayer) {
-              this.stopPlayerAmplitude = stop;
+      // TODO standadize the getter and setter convention in env for other fields.
+      set logLevel(value) {
+          if (value === undefined) {
+              return;
           }
-          if (source === this.wavRecorder) {
-              this.stopRecorderAmplitude = stop;
+          if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {
+              throw new Error(`Unsupported logging level: ${value}`);
           }
+          this.logLevelInternal = value;
       }
-      _stopAmplitudeMonitoring() {
-          var _a, _b;
-          (_a = this.stopPlayerAmplitude) === null || _a === void 0 ? void 0 : _a.call(this);
-          (_b = this.stopRecorderAmplitude) === null || _b === void 0 ? void 0 : _b.call(this);
-          this.stopPlayerAmplitude = undefined;
-          this.stopRecorderAmplitude = undefined;
+      get logLevel() {
+          return this.logLevelInternal;
       }
-      /**
-       * Connects to the Layercode agent using the stored conversation ID and starts the audio conversation
-       * @async
-       * @returns {Promise<void>}
-       */
-      async connect() {
-          if (this.status === 'connecting') {
-              return;
-          }
-          try {
-              this._setStatus('connecting');
-              // Reset turn tracking for clean start
-              this._resetTurnTracking();
-              this._stopAmplitudeMonitoring();
-              this._setupDeviceChangeListener();
-              // Get conversation key from server
-              let authorizeSessionRequestBody = {
-                  agent_id: this.options.agentId,
-                  metadata: this.options.metadata,
-                  sdk_version: SDK_VERSION,
-              };
-              // If we're reconnecting to a previous conversation, we need to include the conversation_id in the request. Otherwise we don't send conversation_id, and a new conversation will be created and the conversation_id will be returned in the response.
-              if (this.options.conversationId) {
-                  authorizeSessionRequestBody.conversation_id = this.options.conversationId;
-              }
-              const authorizeSessionResponse = await fetch(this.options.authorizeSessionEndpoint, {
-                  method: 'POST',
-                  headers: {
-                      'Content-Type': 'application/json',
-                  },
-                  body: JSON.stringify(authorizeSessionRequestBody),
-              });
-              if (!authorizeSessionResponse.ok) {
-                  throw new Error(`Failed to authorize conversation: ${authorizeSessionResponse.statusText}`);
+  }
+
+  // Copyright (c) Microsoft Corporation. All rights reserved.
+  // Licensed under the MIT License.
+  /**
+   * Represent a set of flags as a global singleton.
+   */
+  const env = new EnvImpl();
+
+  // Copyright (c) Microsoft Corporation. All rights reserved.
+  // Licensed under the MIT License.
+  const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && typeof BigInt64Array.from === 'function';
+  const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && typeof BigUint64Array.from === 'function';
+  // a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.
+  const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map([
+      ['float32', Float32Array],
+      ['uint8', Uint8Array],
+      ['int8', Int8Array],
+      ['uint16', Uint16Array],
+      ['int16', Int16Array],
+      ['int32', Int32Array],
+      ['bool', Uint8Array],
+      ['float64', Float64Array],
+      ['uint32', Uint32Array],
+  ]);
+  // a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.
+  const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map([
+      [Float32Array, 'float32'],
+      [Uint8Array, 'uint8'],
+      [Int8Array, 'int8'],
+      [Uint16Array, 'uint16'],
+      [Int16Array, 'int16'],
+      [Int32Array, 'int32'],
+      [Float64Array, 'float64'],
+      [Uint32Array, 'uint32'],
+  ]);
+  if (isBigInt64ArrayAvailable) {
+      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);
+      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');
+  }
+  if (isBigUint64ArrayAvailable) {
+      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);
+      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');
+  }
+  /**
+   * calculate size from dims.
+   *
+   * @param dims the dims array. May be an illegal input.
+   */
+  const calculateSize = (dims) => {
+      let size = 1;
+      for (let i = 0; i < dims.length; i++) {
+          const dim = dims[i];
+          if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {
+              throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);
+          }
+          if (dim < 0) {
+              throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);
+          }
+          size *= dim;
+      }
+      return size;
+  };
+  let Tensor$1 = class Tensor {
+      constructor(arg0, arg1, arg2) {
+          let type;
+          let data;
+          let dims;
+          // check whether arg0 is type or data
+          if (typeof arg0 === 'string') {
+              //
+              // Override: constructor(type, data, ...)
+              //
+              type = arg0;
+              dims = arg2;
+              if (arg0 === 'string') {
+                  // string tensor
+                  if (!Array.isArray(arg1)) {
+                      throw new TypeError('A string tensor\'s data must be a string array.');
+                  }
+                  // we don't check whether every element in the array is string; this is too slow. we assume it's correct and
+                  // error will be populated at inference
+                  data = arg1;
               }
-              const authorizeSessionResponseBody = await authorizeSessionResponse.json();
-              this.conversationId = authorizeSessionResponseBody.conversation_id; // Save the conversation_id for use in future reconnects
-              this.options.conversationId = this.conversationId;
-              // Connect WebSocket
-              this.ws = new WebSocket(`${this._websocketUrl}?${new URLSearchParams({
-                client_session_key: authorizeSessionResponseBody.client_session_key,
-            })}`);
-              const config = authorizeSessionResponseBody.config;
-              console.log('AgentConfig', config);
-              // Store VAD configuration
-              this.vadConfig = config.vad || null;
-              if (config.transcription.trigger === 'push_to_talk') {
-                  this.pushToTalkEnabled = true;
+              else {
+                  // numeric tensor
+                  const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
+                  if (typedArrayConstructor === undefined) {
+                      throw new TypeError(`Unsupported tensor type: ${arg0}.`);
+                  }
+                  if (Array.isArray(arg1)) {
+                      // use 'as any' here because TypeScript's check on type of 'SupportedTypedArrayConstructors.from()' produces
+                      // incorrect results.
+                      // 'typedArrayConstructor' should be one of the typed array prototype objects.
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      data = typedArrayConstructor.from(arg1);
+                  }
+                  else if (arg1 instanceof typedArrayConstructor) {
+                      data = arg1;
+                  }
+                  else {
+                      throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
+                  }
               }
-              else if (config.transcription.trigger === 'automatic') {
-                  this.pushToTalkEnabled = false;
-                  this.canInterrupt = config.transcription.can_interrupt;
+          }
+          else {
+              //
+              // Override: constructor(data, ...)
+              //
+              dims = arg1;
+              if (Array.isArray(arg0)) {
+                  // only boolean[] and string[] is supported
+                  if (arg0.length === 0) {
+                      throw new TypeError('Tensor type cannot be inferred from an empty array.');
+                  }
+                  const firstElementType = typeof arg0[0];
+                  if (firstElementType === 'string') {
+                      type = 'string';
+                      data = arg0;
+                  }
+                  else if (firstElementType === 'boolean') {
+                      type = 'bool';
+                      // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is
+                      // wrong type. We use 'as any' to make it happy.
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      data = Uint8Array.from(arg0);
+                  }
+                  else {
+                      throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
+                  }
               }
               else {
-                  throw new Error(`Unknown trigger: ${config.transcription.trigger}`);
+                  // get tensor type from TypedArray
+                  const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
+                  if (mappedType === undefined) {
+                      throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
+                  }
+                  type = mappedType;
+                  data = arg0;
               }
-              // Bind the websocket message callbacks
-              this.ws.onmessage = this._handleWebSocketMessage;
-              this.ws.onopen = () => {
-                  console.log('WebSocket connection established');
-                  this._setStatus('connected');
-                  this.options.onConnect({ conversationId: this.conversationId });
-                  // Attempt to send ready message if recorder already started
-                  this._sendReadyIfNeeded();
-              };
-              this.ws.onclose = () => {
-                  console.log('WebSocket connection closed');
-                  this.ws = null;
-                  this._performDisconnectCleanup().catch((error) => {
-                      console.error('Error during disconnect cleanup:', error);
-                      this.options.onError(error instanceof Error ? error : new Error(String(error)));
-                  });
-              };
-              this.ws.onerror = (error) => {
-                  console.error('WebSocket error:', error);
-                  this._setStatus('error');
-                  this.options.onError(new Error('WebSocket connection error'));
-              };
-              // Initialize audio player
-              await this.wavPlayer.connect();
-              // Set up audio player amplitude monitoring
-              this._setupAmplitudeMonitoring(this.wavPlayer, this.options.onAgentAmplitudeChange, (amp) => (this.agentAudioAmplitude = amp));
-              // wavRecorder will be started from the onDeviceSwitched callback,
-              // which is called when the device is first initialized and also when the device is switched
-              // this is to ensure that the device is initialized before the recorder is started
           }
-          catch (error) {
-              console.error('Error connecting to Layercode agent:', error);
-              this._setStatus('error');
-              this.options.onError(error instanceof Error ? error : new Error(String(error)));
-              throw error;
+          // type and data is processed, now processing dims
+          if (dims === undefined) {
+              // assume 1-D tensor if dims omitted
+              dims = [data.length];
           }
-      }
-      _resetTurnTracking() {
-          this.currentTurnId = null;
-          console.debug('Reset turn tracking state');
-      }
-      async disconnect() {
-          if (this.status === 'disconnected') {
-              return;
+          else if (!Array.isArray(dims)) {
+              throw new TypeError('A tensor\'s dims must be a number array');
           }
-          if (this.ws) {
-              this.ws.onopen = null;
-              this.ws.onclose = null;
-              this.ws.onerror = null;
-              this.ws.onmessage = null;
-              this.ws.close();
-              this.ws = null;
+          // perform check
+          const size = calculateSize(dims);
+          if (size !== data.length) {
+              throw new Error(`Tensor's size(${size}) does not match data length(${data.length}).`);
           }
-          await this._performDisconnectCleanup();
-      }
-      /**
-       * Gets the microphone MediaStream used by this client
-       * @returns {MediaStream|null} The microphone stream or null if not initialized
-       */
-      getStream() {
-          return this.wavRecorder.getStream();
+          this.dims = dims;
+          this.type = type;
+          this.data = data;
+          this.size = size;
       }
+      // #endregion
       /**
-       * Switches the input device for the microphone and restarts recording
-       * @param {string} deviceId - The deviceId of the new microphone
+       * Create a new tensor object from image object
+       *
+       * @param buffer - Extracted image buffer data - assuming RGBA format
+       * @param imageFormat - input image configuration - required configurations height, width, format
+       * @param tensorFormat - output tensor configuration - Default is RGB format
        */
-      async setInputDevice(deviceId) {
-          var _a, _b, _c;
-          try {
-              const normalizedDeviceId = !deviceId || deviceId === 'default' ? null : deviceId;
-              this.useSystemDefaultDevice = normalizedDeviceId === null;
-              this.deviceId = normalizedDeviceId;
-              // Restart recording with the new device
-              await this._restartAudioRecording();
-              // Reinitialize VAD with the new audio stream if VAD is enabled
-              const shouldUseVAD = !this.pushToTalkEnabled && ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
-              if (shouldUseVAD) {
-                  console.debug('Reinitializing VAD with new audio stream');
-                  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');
-              console.debug(`Successfully switched to input device: ${reportedDeviceId}`);
+      static bufferToTensor(buffer, options) {
+          if (buffer === undefined) {
+              throw new Error('Image buffer must be defined');
           }
-          catch (error) {
-              console.error(`Failed to switch to input device ${deviceId}:`, error);
-              throw new Error(`Failed to switch to input device: ${error instanceof Error ? error.message : String(error)}`);
-          }
-      }
-      /**
-       * Restarts audio recording after a device switch to ensure audio is captured from the new device
-       */
-      async _restartAudioRecording() {
-          var _a, _b;
-          try {
-              console.debug('Restarting audio recording after device switch...');
-              try {
-                  await this.wavRecorder.end();
-              }
-              catch (_c) {
-                  // Ignore cleanup errors
-              }
-              // Start with new device
-              const targetDeviceId = this.useSystemDefaultDevice ? undefined : this.deviceId || undefined;
-              await this.wavRecorder.begin(targetDeviceId);
-              await this.wavRecorder.record(this._handleDataAvailable, 1638);
-              // Re-setup amplitude monitoring with the new stream
-              this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
-              const previousReportedDeviceId = this.lastReportedDeviceId;
-              const stream = this.wavRecorder.getStream();
-              const activeTrack = (stream === null || stream === void 0 ? void 0 : stream.getAudioTracks()[0]) || null;
-              const trackSettings = activeTrack && typeof activeTrack.getSettings === 'function' ? activeTrack.getSettings() : null;
-              const trackDeviceId = trackSettings && typeof trackSettings.deviceId === 'string' ? trackSettings.deviceId : null;
-              this.activeDeviceId = trackDeviceId !== null && trackDeviceId !== void 0 ? trackDeviceId : (this.useSystemDefaultDevice ? null : this.deviceId);
-              if (!this.recorderStarted) {
-                  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');
-              if (reportedDeviceId !== previousReportedDeviceId) {
-                  this.lastReportedDeviceId = reportedDeviceId;
-                  if (this.options.onDeviceSwitched) {
-                      this.options.onDeviceSwitched(reportedDeviceId);
-                  }
-              }
-              console.debug('Audio recording restart completed successfully');
-          }
-          catch (error) {
-              console.error('Error restarting audio recording after device switch:', error);
-              this.options.onError(error instanceof Error ? error : new Error(String(error)));
-          }
-      }
-      /**
-       * Reinitializes VAD with a new stream (used after device switching)
-       */
-      async _reinitializeVAD(stream) {
-          // Clean up existing VAD
-          if (this.vad) {
-              this.vad.pause();
-              this.vad.destroy();
-              this.vad = null;
+          if (options.height === undefined || options.width === undefined) {
+              throw new Error('Image height and width must be defined');
           }
-          // Reinitialize with new stream
-          if (stream) {
-              this._initializeVAD();
+          const { height, width } = options;
+          const norm = options.norm;
+          let normMean;
+          let normBias;
+          if (norm === undefined || norm.mean === undefined) {
+              normMean = 255;
           }
-      }
-      /**
-       * Sets up the device change event listener
-       */
-      _setupDeviceChangeListener() {
-          if (!this.deviceChangeListener) {
-              this.deviceChangeListener = async (devices) => {
-                  try {
-                      const defaultDevice = devices.find((device) => device.default);
-                      const usingDefaultDevice = this.useSystemDefaultDevice;
-                      const previousDefaultDeviceKey = this.lastKnownSystemDefaultDeviceKey;
-                      const currentDefaultDeviceKey = this._getDeviceComparisonKey(defaultDevice);
-                      let shouldSwitch = !this.recorderStarted;
-                      if (!shouldSwitch) {
-                          if (usingDefaultDevice) {
-                              if (!defaultDevice) {
-                                  shouldSwitch = true;
-                              }
-                              else if (this.activeDeviceId && defaultDevice.deviceId !== 'default' && defaultDevice.deviceId !== this.activeDeviceId) {
-                                  shouldSwitch = true;
-                              }
-                              else if ((previousDefaultDeviceKey && previousDefaultDeviceKey !== currentDefaultDeviceKey) ||
-                                  (!previousDefaultDeviceKey && !currentDefaultDeviceKey && this.recorderStarted)) {
-                                  shouldSwitch = true;
-                              }
-                          }
-                          else {
-                              const matchesRequestedDevice = devices.some((device) => device.deviceId === this.deviceId || device.deviceId === this.activeDeviceId);
-                              shouldSwitch = !matchesRequestedDevice;
-                          }
-                      }
-                      this.lastKnownSystemDefaultDeviceKey = currentDefaultDeviceKey;
-                      if (shouldSwitch) {
-                          console.debug('Selecting fallback audio input device');
-                          const fallbackDevice = defaultDevice || devices[0];
-                          if (fallbackDevice) {
-                              const fallbackId = fallbackDevice.default ? 'default' : fallbackDevice.deviceId;
-                              await this.setInputDevice(fallbackId);
-                          }
-                          else {
-                              console.warn('No alternative audio device found');
-                          }
-                      }
-                  }
-                  catch (error) {
-                      this.options.onError(error instanceof Error ? error : new Error(String(error)));
-                  }
-              };
+          else {
+              normMean = norm.mean;
           }
-          this.wavRecorder.listenForDeviceChange(this.deviceChangeListener);
-      }
-      _teardownDeviceListeners() {
-          this.wavRecorder.listenForDeviceChange(null);
-      }
-      async _performDisconnectCleanup() {
-          var _a, _b;
-          this.deviceId = null;
-          this.activeDeviceId = null;
-          this.useSystemDefaultDevice = false;
-          this.lastReportedDeviceId = null;
-          this.lastKnownSystemDefaultDeviceKey = null;
-          this.recorderStarted = false;
-          this.readySent = false;
-          this._stopAmplitudeMonitoring();
-          this._teardownDeviceListeners();
-          if (this.vad) {
-              this.vad.pause();
-              this.vad.destroy();
-              this.vad = null;
+          if (norm === undefined || norm.bias === undefined) {
+              normBias = 0;
           }
-          await this.wavRecorder.quit();
-          (_b = (_a = this.wavPlayer).stop) === null || _b === void 0 ? void 0 : _b.call(_a);
-          this.wavPlayer.disconnect();
-          this._resetTurnTracking();
-          this.options.conversationId = this.conversationId;
-          this.userAudioAmplitude = 0;
-          this.agentAudioAmplitude = 0;
-          this._setStatus('disconnected');
-          this.options.onDisconnect();
-      }
-      _getDeviceComparisonKey(device) {
-          if (!device || typeof device !== 'object') {
-              return null;
+          else {
+              normBias = norm.bias;
           }
-          const deviceId = typeof device.deviceId === 'string' ? device.deviceId : '';
-          if (deviceId && deviceId !== 'default') {
-              return deviceId;
+          const inputformat = options.bitmapFormat !== undefined ? options.bitmapFormat : 'RGBA';
+          // default value is RGBA since imagedata and HTMLImageElement uses it
+          const outputformat = options.tensorFormat !== undefined ?
+              (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') :
+              'RGB';
+          const offset = height * width;
+          const float32Data = outputformat === 'RGBA' ? new Float32Array(offset * 4) : new Float32Array(offset * 3);
+          // Default pointer assignments
+          let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+          let rTensorPointer = 0, gTensorPointer = offset, bTensorPointer = offset * 2, aTensorPointer = -1;
+          // Updating the pointer assignments based on the input image format
+          if (inputformat === 'RGB') {
+              step = 3;
+              rImagePointer = 0;
+              gImagePointer = 1;
+              bImagePointer = 2;
+              aImagePointer = -1;
           }
-          const groupId = typeof device.groupId === 'string' ? device.groupId : '';
-          if (groupId) {
-              return groupId;
+          // Updating the pointer assignments based on the output tensor format
+          if (outputformat === 'RGBA') {
+              aTensorPointer = offset * 3;
           }
-          const label = typeof device.label === 'string' ? device.label : '';
-          if (label) {
-              return label;
+          else if (outputformat === 'RBG') {
+              rTensorPointer = 0;
+              bTensorPointer = offset;
+              gTensorPointer = offset * 2;
           }
-          return null;
-      }
-      /**
-       * Mutes the microphone to stop sending audio to the server
-       * The connection and recording remain active for quick unmute
-       */
-      mute() {
-          if (!this.isMuted) {
-              this.isMuted = true;
-              console.log('Microphone muted');
-              this.options.onMuteStateChange(true);
+          else if (outputformat === 'BGR') {
+              bTensorPointer = 0;
+              gTensorPointer = offset;
+              rTensorPointer = offset * 2;
           }
-      }
-      /**
-       * Unmutes the microphone to resume sending audio to the server
-       */
-      unmute() {
-          if (this.isMuted) {
-              this.isMuted = false;
-              console.log('Microphone unmuted');
-              this.options.onMuteStateChange(false);
+          for (let i = 0; i < offset; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
+              float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias) / normMean;
+              float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias) / normMean;
+              float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias) / normMean;
+              if (aTensorPointer !== -1 && aImagePointer !== -1) {
+                  float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias) / normMean;
+              }
           }
+          // Float32Array -> ort.Tensor
+          const outputTensor = outputformat === 'RGBA' ? new Tensor('float32', float32Data, [1, 4, height, width]) :
+              new Tensor('float32', float32Data, [1, 3, height, width]);
+          return outputTensor;
       }
-  }
-
-  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-  function getDefaultExportFromCjs (x) {
-  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-  }
-
-  function getAugmentedNamespace(n) {
-    if (n.__esModule) return n;
-    var f = n.default;
-  	if (typeof f == "function") {
-  		var a = function a () {
-  			if (this instanceof a) {
-          return Reflect.construct(f, arguments, this.constructor);
-  			}
-  			return f.apply(this, arguments);
-  		};
-  		a.prototype = f.prototype;
-    } else a = {};
-    Object.defineProperty(a, '__esModule', {value: true});
-  	Object.keys(n).forEach(function (k) {
-  		var d = Object.getOwnPropertyDescriptor(n, k);
-  		Object.defineProperty(a, k, d.get ? d : {
-  			enumerable: true,
-  			get: function () {
-  				return n[k];
-  			}
-  		});
-  	});
-  	return a;
-  }
-
-  var dist = {};
-
-  var assetPath = {};
-
-  Object.defineProperty(assetPath, "__esModule", { value: true });
-  assetPath.baseAssetPath = void 0;
-  // nextjs@14 bundler may attempt to execute this during SSR and crash
-  const isWeb = typeof window !== "undefined" && typeof window.document !== "undefined";
-  const currentScript = isWeb
-      ? window.document.currentScript
-      : null;
-  let basePath = "/";
-  if (currentScript) {
-      basePath = currentScript.src
-          .replace(/#.*$/, "")
-          .replace(/\?.*$/, "")
-          .replace(/\/[^\/]+$/, "/");
-  }
-  assetPath.baseAssetPath = basePath;
-
-  var defaultModelFetcher$1 = {};
-
-  Object.defineProperty(defaultModelFetcher$1, "__esModule", { value: true });
-  defaultModelFetcher$1.defaultModelFetcher = void 0;
-  const defaultModelFetcher = (path) => {
-      return fetch(path).then((model) => model.arrayBuffer());
-  };
-  defaultModelFetcher$1.defaultModelFetcher = defaultModelFetcher;
-
-  var frameProcessor = {};
-
-  var logging = {};
-
-  (function (exports) {
-  	Object.defineProperty(exports, "__esModule", { value: true });
-  	exports.log = exports.LOG_PREFIX = void 0;
-  	exports.LOG_PREFIX = "[VAD]";
-  	const levels = ["error", "debug", "warn"];
-  	function getLog(level) {
-  	    return (...args) => {
-  	        console[level](exports.LOG_PREFIX, ...args);
-  	    };
-  	}
-  	const _log = levels.reduce((acc, level) => {
-  	    acc[level] = getLog(level);
-  	    return acc;
-  	}, {});
-  	exports.log = _log;
-  	
-  } (logging));
-
-  var messages = {};
-
-  Object.defineProperty(messages, "__esModule", { value: true });
-  messages.Message = void 0;
-  var Message;
-  (function (Message) {
-      Message["AudioFrame"] = "AUDIO_FRAME";
-      Message["SpeechStart"] = "SPEECH_START";
-      Message["VADMisfire"] = "VAD_MISFIRE";
-      Message["SpeechEnd"] = "SPEECH_END";
-      Message["SpeechStop"] = "SPEECH_STOP";
-      Message["SpeechRealStart"] = "SPEECH_REAL_START";
-      Message["FrameProcessed"] = "FRAME_PROCESSED";
-  })(Message || (messages.Message = Message = {}));
-
-  /*
-  Some of this code, together with the default options found in index.ts,
-  were taken (or took inspiration) from https://github.com/snakers4/silero-vad
-  */
-  Object.defineProperty(frameProcessor, "__esModule", { value: true });
-  frameProcessor.FrameProcessor = frameProcessor.validateOptions = frameProcessor.defaultV5FrameProcessorOptions = frameProcessor.defaultLegacyFrameProcessorOptions = void 0;
-  const logging_1$3 = logging;
-  const messages_1 = messages;
-  const RECOMMENDED_FRAME_SAMPLES = [512, 1024, 1536];
-  frameProcessor.defaultLegacyFrameProcessorOptions = {
-      positiveSpeechThreshold: 0.5,
-      negativeSpeechThreshold: 0.5 - 0.15,
-      preSpeechPadFrames: 1,
-      redemptionFrames: 8,
-      frameSamples: 1536,
-      minSpeechFrames: 3,
-      submitUserSpeechOnPause: false,
-  };
-  frameProcessor.defaultV5FrameProcessorOptions = {
-      positiveSpeechThreshold: 0.5,
-      negativeSpeechThreshold: 0.5 - 0.15,
-      preSpeechPadFrames: 3,
-      redemptionFrames: 24,
-      frameSamples: 512,
-      minSpeechFrames: 9,
-      submitUserSpeechOnPause: false,
-  };
-  function validateOptions(options) {
-      if (!RECOMMENDED_FRAME_SAMPLES.includes(options.frameSamples)) {
-          logging_1$3.log.warn("You are using an unusual frame size");
-      }
-      if (options.positiveSpeechThreshold < 0 ||
-          options.positiveSpeechThreshold > 1) {
-          logging_1$3.log.error("positiveSpeechThreshold should be a number between 0 and 1");
-      }
-      if (options.negativeSpeechThreshold < 0 ||
-          options.negativeSpeechThreshold > options.positiveSpeechThreshold) {
-          logging_1$3.log.error("negativeSpeechThreshold should be between 0 and positiveSpeechThreshold");
-      }
-      if (options.preSpeechPadFrames < 0) {
-          logging_1$3.log.error("preSpeechPadFrames should be positive");
-      }
-      if (options.redemptionFrames < 0) {
-          logging_1$3.log.error("redemptionFrames should be positive");
-      }
-  }
-  frameProcessor.validateOptions = validateOptions;
-  const concatArrays = (arrays) => {
-      const sizes = arrays.reduce((out, next) => {
-          out.push(out.at(-1) + next.length);
-          return out;
-      }, [0]);
-      const outArray = new Float32Array(sizes.at(-1));
-      arrays.forEach((arr, index) => {
-          const place = sizes[index];
-          outArray.set(arr, place);
-      });
-      return outArray;
-  };
-  class FrameProcessor {
-      constructor(modelProcessFunc, modelResetFunc, options) {
-          this.modelProcessFunc = modelProcessFunc;
-          this.modelResetFunc = modelResetFunc;
-          this.options = options;
-          this.speaking = false;
-          this.redemptionCounter = 0;
-          this.speechFrameCount = 0;
-          this.active = false;
-          this.speechRealStartFired = false;
-          this.reset = () => {
-              this.speaking = false;
-              this.speechRealStartFired = false;
-              this.audioBuffer = [];
-              this.modelResetFunc();
-              this.redemptionCounter = 0;
-              this.speechFrameCount = 0;
-          };
-          this.pause = (handleEvent) => {
-              this.active = false;
-              if (this.options.submitUserSpeechOnPause) {
-                  this.endSegment(handleEvent);
-              }
-              else {
-                  this.reset();
-              }
-          };
-          this.resume = () => {
-              this.active = true;
-          };
-          this.endSegment = (handleEvent) => {
-              const audioBuffer = this.audioBuffer;
-              this.audioBuffer = [];
-              const speaking = this.speaking;
-              this.reset();
-              if (speaking) {
-                  const speechFrameCount = audioBuffer.reduce((acc, item) => {
-                      return item.isSpeech ? (acc + 1) : acc;
-                  }, 0);
-                  if (speechFrameCount >= this.options.minSpeechFrames) {
-                      const audio = concatArrays(audioBuffer.map((item) => item.frame));
-                      handleEvent({ msg: messages_1.Message.SpeechEnd, audio });
+      static async fromImage(image, options) {
+          // checking the type of image object
+          const isHTMLImageEle = typeof (HTMLImageElement) !== 'undefined' && image instanceof HTMLImageElement;
+          const isImageDataEle = typeof (ImageData) !== 'undefined' && image instanceof ImageData;
+          const isImageBitmap = typeof (ImageBitmap) !== 'undefined' && image instanceof ImageBitmap;
+          const isURL = typeof (String) !== 'undefined' && (image instanceof String || typeof image === 'string');
+          let data;
+          let tensorConfig = {};
+          // filling and checking image configuration options
+          if (isHTMLImageEle) {
+              // HTMLImageElement - image object - format is RGBA by default
+              const canvas = document.createElement('canvas');
+              const pixels2DContext = canvas.getContext('2d');
+              if (pixels2DContext != null) {
+                  let height = image.naturalHeight;
+                  let width = image.naturalWidth;
+                  if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {
+                      height = options.resizedHeight;
+                      width = options.resizedWidth;
+                  }
+                  if (options !== undefined) {
+                      tensorConfig = options;
+                      if (options.tensorFormat !== undefined) {
+                          throw new Error('Image input config format must be RGBA for HTMLImageElement');
+                      }
+                      else {
+                          tensorConfig.tensorFormat = 'RGBA';
+                      }
+                      if (options.height !== undefined && options.height !== height) {
+                          throw new Error('Image input config height doesn\'t match HTMLImageElement height');
+                      }
+                      else {
+                          tensorConfig.height = height;
+                      }
+                      if (options.width !== undefined && options.width !== width) {
+                          throw new Error('Image input config width doesn\'t match HTMLImageElement width');
+                      }
+                      else {
+                          tensorConfig.width = width;
+                      }
                   }
                   else {
-                      handleEvent({ msg: messages_1.Message.VADMisfire });
+                      tensorConfig.tensorFormat = 'RGBA';
+                      tensorConfig.height = height;
+                      tensorConfig.width = width;
                   }
+                  canvas.width = width;
+                  canvas.height = height;
+                  pixels2DContext.drawImage(image, 0, 0, width, height);
+                  data = pixels2DContext.getImageData(0, 0, width, height).data;
               }
-              return {};
-          };
-          this.process = async (frame, handleEvent) => {
-              if (!this.active) {
-                  return;
+              else {
+                  throw new Error('Can not access image data');
               }
-              const probs = await this.modelProcessFunc(frame);
-              const isSpeech = probs.isSpeech >= this.options.positiveSpeechThreshold;
-              handleEvent({ probs, msg: messages_1.Message.FrameProcessed, frame });
-              this.audioBuffer.push({
-                  frame,
-                  isSpeech,
-              });
-              if (isSpeech) {
-                  this.speechFrameCount++;
-                  this.redemptionCounter = 0;
+          }
+          else if (isImageDataEle) {
+              // ImageData - image object - format is RGBA by default
+              const format = 'RGBA';
+              let height;
+              let width;
+              if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {
+                  height = options.resizedHeight;
+                  width = options.resizedWidth;
               }
-              if (isSpeech && !this.speaking) {
-                  this.speaking = true;
-                  handleEvent({ msg: messages_1.Message.SpeechStart });
+              else {
+                  height = image.height;
+                  width = image.width;
               }
-              if (this.speaking &&
-                  this.speechFrameCount === this.options.minSpeechFrames &&
-                  !this.speechRealStartFired) {
-                  this.speechRealStartFired = true;
-                  handleEvent({ msg: messages_1.Message.SpeechRealStart });
+              if (options !== undefined) {
+                  tensorConfig = options;
+                  if (options.bitmapFormat !== undefined && options.bitmapFormat !== format) {
+                      throw new Error('Image input config format must be RGBA for ImageData');
+                  }
+                  else {
+                      tensorConfig.bitmapFormat = 'RGBA';
+                  }
               }
-              if (probs.isSpeech < this.options.negativeSpeechThreshold &&
-                  this.speaking &&
-                  ++this.redemptionCounter >= this.options.redemptionFrames) {
-                  this.redemptionCounter = 0;
-                  this.speechFrameCount = 0;
-                  this.speaking = false;
-                  this.speechRealStartFired = false;
-                  const audioBuffer = this.audioBuffer;
-                  this.audioBuffer = [];
-                  const speechFrameCount = audioBuffer.reduce((acc, item) => {
-                      return item.isSpeech ? (acc + 1) : acc;
-                  }, 0);
-                  if (speechFrameCount >= this.options.minSpeechFrames) {
-                      const audio = concatArrays(audioBuffer.map((item) => item.frame));
-                      handleEvent({ msg: messages_1.Message.SpeechEnd, audio });
+              else {
+                  tensorConfig.bitmapFormat = 'RGBA';
+              }
+              tensorConfig.height = height;
+              tensorConfig.width = width;
+              if (options !== undefined) {
+                  const tempCanvas = document.createElement('canvas');
+                  tempCanvas.width = width;
+                  tempCanvas.height = height;
+                  const pixels2DContext = tempCanvas.getContext('2d');
+                  if (pixels2DContext != null) {
+                      pixels2DContext.putImageData(image, 0, 0);
+                      data = pixels2DContext.getImageData(0, 0, width, height).data;
                   }
                   else {
-                      handleEvent({ msg: messages_1.Message.VADMisfire });
+                      throw new Error('Can not access image data');
                   }
               }
-              if (!this.speaking) {
-                  while (this.audioBuffer.length > this.options.preSpeechPadFrames) {
-                      this.audioBuffer.shift();
-                  }
-                  this.speechFrameCount = 0;
+              else {
+                  data = image.data;
               }
-          };
-          this.audioBuffer = [];
-          this.reset();
-      }
-  }
-  frameProcessor.FrameProcessor = FrameProcessor;
-
-  var nonRealTimeVad = {};
-
-  var ortWeb_min = {exports: {}};
-
-  // Copyright (c) Microsoft Corporation. All rights reserved.
-  // Licensed under the MIT License.
-  const backends = {};
-  const backendsSortedByPriority = [];
-  /**
-   * Register a backend.
-   *
-   * @param name - the name as a key to lookup as an execution provider.
-   * @param backend - the backend object.
-   * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority
-   * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.
-   *
-   * @internal
-   */
-  const registerBackend = (name, backend, priority) => {
-      if (backend && typeof backend.init === 'function' && typeof backend.createSessionHandler === 'function') {
-          const currentBackend = backends[name];
-          if (currentBackend === undefined) {
-              backends[name] = { backend, priority };
-          }
-          else if (currentBackend.priority > priority) {
-              // same name is already registered with a higher priority. skip registeration.
-              return;
           }
-          else if (currentBackend.priority === priority) {
-              if (currentBackend.backend !== backend) {
-                  throw new Error(`cannot register backend "${name}" using priority ${priority}`);
+          else if (isImageBitmap) {
+              // ImageBitmap - image object - format must be provided by user
+              if (options === undefined) {
+                  throw new Error('Please provide image config with format for Imagebitmap');
               }
-          }
-          if (priority >= 0) {
-              const i = backendsSortedByPriority.indexOf(name);
-              if (i !== -1) {
-                  backendsSortedByPriority.splice(i, 1);
+              if (options.bitmapFormat !== undefined) {
+                  throw new Error('Image input config format must be defined for ImageBitmap');
               }
-              for (let i = 0; i < backendsSortedByPriority.length; i++) {
-                  if (backends[backendsSortedByPriority[i]].priority <= priority) {
-                      backendsSortedByPriority.splice(i, 0, name);
-                      return;
+              const pixels2DContext = document.createElement('canvas').getContext('2d');
+              if (pixels2DContext != null) {
+                  const height = image.height;
+                  const width = image.width;
+                  pixels2DContext.drawImage(image, 0, 0, width, height);
+                  data = pixels2DContext.getImageData(0, 0, width, height).data;
+                  if (options !== undefined) {
+                      // using square brackets to avoid TS error - type 'never'
+                      if (options.height !== undefined && options.height !== height) {
+                          throw new Error('Image input config height doesn\'t match ImageBitmap height');
+                      }
+                      else {
+                          tensorConfig.height = height;
+                      }
+                      // using square brackets to avoid TS error - type 'never'
+                      if (options.width !== undefined && options.width !== width) {
+                          throw new Error('Image input config width doesn\'t match ImageBitmap width');
+                      }
+                      else {
+                          tensorConfig.width = width;
+                      }
+                  }
+                  else {
+                      tensorConfig.height = height;
+                      tensorConfig.width = width;
                   }
+                  return Tensor.bufferToTensor(data, tensorConfig);
+              }
+              else {
+                  throw new Error('Can not access image data');
               }
-              backendsSortedByPriority.push(name);
           }
-          return;
+          else if (isURL) {
+              return new Promise((resolve, reject) => {
+                  const canvas = document.createElement('canvas');
+                  const context = canvas.getContext('2d');
+                  if (!image || !context) {
+                      return reject();
+                  }
+                  const newImage = new Image();
+                  newImage.crossOrigin = 'Anonymous';
+                  newImage.src = image;
+                  newImage.onload = () => {
+                      canvas.width = newImage.width;
+                      canvas.height = newImage.height;
+                      context.drawImage(newImage, 0, 0, canvas.width, canvas.height);
+                      const img = context.getImageData(0, 0, canvas.width, canvas.height);
+                      if (options !== undefined) {
+                          // using square brackets to avoid TS error - type 'never'
+                          if (options.height !== undefined && options.height !== canvas.height) {
+                              throw new Error('Image input config height doesn\'t match ImageBitmap height');
+                          }
+                          else {
+                              tensorConfig.height = canvas.height;
+                          }
+                          // using square brackets to avoid TS error - type 'never'
+                          if (options.width !== undefined && options.width !== canvas.width) {
+                              throw new Error('Image input config width doesn\'t match ImageBitmap width');
+                          }
+                          else {
+                              tensorConfig.width = canvas.width;
+                          }
+                      }
+                      else {
+                          tensorConfig.height = canvas.height;
+                          tensorConfig.width = canvas.width;
+                      }
+                      resolve(Tensor.bufferToTensor(img.data, tensorConfig));
+                  };
+              });
+          }
+          else {
+              throw new Error('Input data provided is not supported - aborted tensor creation');
+          }
+          if (data !== undefined) {
+              return Tensor.bufferToTensor(data, tensorConfig);
+          }
+          else {
+              throw new Error('Input data provided is not supported - aborted tensor creation');
+          }
       }
-      throw new TypeError('not a valid backend');
-  };
-  /**
-   * Resolve backend by specified hints.
-   *
-   * @param backendHints - a list of execution provider names to lookup. If omitted use registered backends as list.
-   * @returns a promise that resolves to the backend.
-   *
-   * @internal
-   */
-  const resolveBackend = async (backendHints) => {
-      const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;
-      const errors = [];
-      for (const backendName of backendNames) {
-          const backendInfo = backends[backendName];
-          if (backendInfo) {
-              if (backendInfo.initialized) {
-                  return backendInfo.backend;
+      toImageData(options) {
+          var _a, _b;
+          const pixels2DContext = document.createElement('canvas').getContext('2d');
+          let image;
+          if (pixels2DContext != null) {
+              // Default values for height and width & format
+              const width = this.dims[3];
+              const height = this.dims[2];
+              const channels = this.dims[1];
+              const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';
+              const normMean = options !== undefined ? (((_a = options.norm) === null || _a === void 0 ? void 0 : _a.mean) !== undefined ? options.norm.mean : 255) : 255;
+              const normBias = options !== undefined ? (((_b = options.norm) === null || _b === void 0 ? void 0 : _b.bias) !== undefined ? options.norm.bias : 0) : 0;
+              const offset = height * width;
+              if (options !== undefined) {
+                  if (options.height !== undefined && options.height !== height) {
+                      throw new Error('Image output config height doesn\'t match tensor height');
+                  }
+                  if (options.width !== undefined && options.width !== width) {
+                      throw new Error('Image output config width doesn\'t match tensor width');
+                  }
+                  if (options.format !== undefined && (channels === 4 && options.format !== 'RGBA') ||
+                      (channels === 3 && (options.format !== 'RGB' && options.format !== 'BGR'))) {
+                      throw new Error('Tensor format doesn\'t match input tensor dims');
+                  }
               }
-              else if (backendInfo.aborted) {
-                  continue; // current backend is unavailable; try next
+              // Default pointer assignments
+              const step = 4;
+              let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+              let rTensorPointer = 0, gTensorPointer = offset, bTensorPointer = offset * 2, aTensorPointer = -1;
+              // Updating the pointer assignments based on the input image format
+              if (inputformat === 'RGBA') {
+                  rTensorPointer = 0;
+                  gTensorPointer = offset;
+                  bTensorPointer = offset * 2;
+                  aTensorPointer = offset * 3;
               }
-              const isInitializing = !!backendInfo.initPromise;
-              try {
-                  if (!isInitializing) {
-                      backendInfo.initPromise = backendInfo.backend.init();
-                  }
-                  await backendInfo.initPromise;
-                  backendInfo.initialized = true;
-                  return backendInfo.backend;
+              else if (inputformat === 'RGB') {
+                  rTensorPointer = 0;
+                  gTensorPointer = offset;
+                  bTensorPointer = offset * 2;
               }
-              catch (e) {
-                  if (!isInitializing) {
-                      errors.push({ name: backendName, err: e });
-                  }
-                  backendInfo.aborted = true;
+              else if (inputformat === 'RBG') {
+                  rTensorPointer = 0;
+                  bTensorPointer = offset;
+                  gTensorPointer = offset * 2;
               }
-              finally {
-                  delete backendInfo.initPromise;
+              image = pixels2DContext.createImageData(width, height);
+              for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
+                  image.data[rImagePointer] = (this.data[rTensorPointer++] - normBias) * normMean; // R value
+                  image.data[gImagePointer] = (this.data[gTensorPointer++] - normBias) * normMean; // G value
+                  image.data[bImagePointer] = (this.data[bTensorPointer++] - normBias) * normMean; // B value
+                  image.data[aImagePointer] =
+                      aTensorPointer === -1 ? 255 : (this.data[aTensorPointer++] - normBias) * normMean; // A value
               }
           }
+          else {
+              throw new Error('Can not access image data');
+          }
+          return image;
       }
-      throw new Error(`no available backend found. ERR: ${errors.map(e => `[${e.name}] ${e.err}`).join(', ')}`);
-  };
-
-  // Copyright (c) Microsoft Corporation. All rights reserved.
-  // Licensed under the MIT License.
-  class EnvImpl {
-      constructor() {
-          this.wasm = {};
-          this.webgl = {};
-          this.logLevelInternal = 'warning';
-      }
-      // TODO standadize the getter and setter convention in env for other fields.
-      set logLevel(value) {
-          if (value === undefined) {
-              return;
-          }
-          if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {
-              throw new Error(`Unsupported logging level: ${value}`);
-          }
-          this.logLevelInternal = value;
-      }
-      get logLevel() {
-          return this.logLevelInternal;
+      // #endregion
+      // #region tensor utilities
+      reshape(dims) {
+          return new Tensor(this.type, this.data, dims);
       }
-  }
+  };
 
   // Copyright (c) Microsoft Corporation. All rights reserved.
   // Licensed under the MIT License.
-  /**
-   * Represent a set of flags as a global singleton.
-   */
-  const env = new EnvImpl();
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const Tensor = Tensor$1;
 
   // Copyright (c) Microsoft Corporation. All rights reserved.
   // Licensed under the MIT License.
-  const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && typeof BigInt64Array.from === 'function';
-  const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && typeof BigUint64Array.from === 'function';
-  // a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.
-  const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map([
-      ['float32', Float32Array],
-      ['uint8', Uint8Array],
-      ['int8', Int8Array],
-      ['uint16', Uint16Array],
-      ['int16', Int16Array],
-      ['int32', Int32Array],
-      ['bool', Uint8Array],
-      ['float64', Float64Array],
-      ['uint32', Uint32Array],
-  ]);
-  // a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.
-  const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map([
-      [Float32Array, 'float32'],
-      [Uint8Array, 'uint8'],
-      [Int8Array, 'int8'],
-      [Uint16Array, 'uint16'],
-      [Int16Array, 'int16'],
-      [Int32Array, 'int32'],
-      [Float64Array, 'float64'],
-      [Uint32Array, 'uint32'],
-  ]);
-  if (isBigInt64ArrayAvailable) {
-      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);
-      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');
-  }
-  if (isBigUint64ArrayAvailable) {
-      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);
-      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');
-  }
-  /**
-   * calculate size from dims.
-   *
-   * @param dims the dims array. May be an illegal input.
-   */
-  const calculateSize = (dims) => {
-      let size = 1;
-      for (let i = 0; i < dims.length; i++) {
-          const dim = dims[i];
-          if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {
-              throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);
-          }
-          if (dim < 0) {
-              throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);
-          }
-          size *= dim;
+  let InferenceSession$1 = class InferenceSession {
+      constructor(handler) {
+          this.handler = handler;
       }
-      return size;
-  };
-  let Tensor$1 = class Tensor {
-      constructor(arg0, arg1, arg2) {
-          let type;
-          let data;
-          let dims;
-          // check whether arg0 is type or data
-          if (typeof arg0 === 'string') {
-              //
-              // Override: constructor(type, data, ...)
-              //
-              type = arg0;
-              dims = arg2;
-              if (arg0 === 'string') {
-                  // string tensor
-                  if (!Array.isArray(arg1)) {
-                      throw new TypeError('A string tensor\'s data must be a string array.');
-                  }
-                  // we don't check whether every element in the array is string; this is too slow. we assume it's correct and
-                  // error will be populated at inference
-                  data = arg1;
+      async run(feeds, arg1, arg2) {
+          const fetches = {};
+          let options = {};
+          // check inputs
+          if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {
+              throw new TypeError('\'feeds\' must be an object that use input names as keys and OnnxValue as corresponding values.');
+          }
+          let isFetchesEmpty = true;
+          // determine which override is being used
+          if (typeof arg1 === 'object') {
+              if (arg1 === null) {
+                  throw new TypeError('Unexpected argument[1]: cannot be null.');
               }
-              else {
-                  // numeric tensor
-                  const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
-                  if (typedArrayConstructor === undefined) {
-                      throw new TypeError(`Unsupported tensor type: ${arg0}.`);
+              if (arg1 instanceof Tensor) {
+                  throw new TypeError('\'fetches\' cannot be a Tensor');
+              }
+              if (Array.isArray(arg1)) {
+                  if (arg1.length === 0) {
+                      throw new TypeError('\'fetches\' cannot be an empty array.');
                   }
-                  if (Array.isArray(arg1)) {
-                      // use 'as any' here because TypeScript's check on type of 'SupportedTypedArrayConstructors.from()' produces
-                      // incorrect results.
-                      // 'typedArrayConstructor' should be one of the typed array prototype objects.
-                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                      data = typedArrayConstructor.from(arg1);
+                  isFetchesEmpty = false;
+                  // output names
+                  for (const name of arg1) {
+                      if (typeof name !== 'string') {
+                          throw new TypeError('\'fetches\' must be a string array or an object.');
+                      }
+                      if (this.outputNames.indexOf(name) === -1) {
+                          throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
+                      }
+                      fetches[name] = null;
                   }
-                  else if (arg1 instanceof typedArrayConstructor) {
-                      data = arg1;
+                  if (typeof arg2 === 'object' && arg2 !== null) {
+                      options = arg2;
                   }
-                  else {
-                      throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
+                  else if (typeof arg2 !== 'undefined') {
+                      throw new TypeError('\'options\' must be an object.');
                   }
               }
-          }
-          else {
-              //
-              // Override: constructor(data, ...)
-              //
-              dims = arg1;
-              if (Array.isArray(arg0)) {
-                  // only boolean[] and string[] is supported
-                  if (arg0.length === 0) {
-                      throw new TypeError('Tensor type cannot be inferred from an empty array.');
-                  }
-                  const firstElementType = typeof arg0[0];
-                  if (firstElementType === 'string') {
-                      type = 'string';
-                      data = arg0;
+              else {
+                  // decide whether arg1 is fetches or options
+                  // if any output name is present and its value is valid OnnxValue, we consider it fetches
+                  let isFetches = false;
+                  const arg1Keys = Object.getOwnPropertyNames(arg1);
+                  for (const name of this.outputNames) {
+                      if (arg1Keys.indexOf(name) !== -1) {
+                          const v = arg1[name];
+                          if (v === null || v instanceof Tensor) {
+                              isFetches = true;
+                              isFetchesEmpty = false;
+                              fetches[name] = v;
+                          }
+                      }
                   }
-                  else if (firstElementType === 'boolean') {
-                      type = 'bool';
-                      // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is
-                      // wrong type. We use 'as any' to make it happy.
-                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                      data = Uint8Array.from(arg0);
+                  if (isFetches) {
+                      if (typeof arg2 === 'object' && arg2 !== null) {
+                          options = arg2;
+                      }
+                      else if (typeof arg2 !== 'undefined') {
+                          throw new TypeError('\'options\' must be an object.');
+                      }
                   }
                   else {
-                      throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
-                  }
-              }
-              else {
-                  // get tensor type from TypedArray
-                  const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
-                  if (mappedType === undefined) {
-                      throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
+                      options = arg1;
                   }
-                  type = mappedType;
-                  data = arg0;
               }
           }
-          // type and data is processed, now processing dims
-          if (dims === undefined) {
-              // assume 1-D tensor if dims omitted
-              dims = [data.length];
+          else if (typeof arg1 !== 'undefined') {
+              throw new TypeError('Unexpected argument[1]: must be \'fetches\' or \'options\'.');
           }
-          else if (!Array.isArray(dims)) {
-              throw new TypeError('A tensor\'s dims must be a number array');
+          // check if all inputs are in feed
+          for (const name of this.inputNames) {
+              if (typeof feeds[name] === 'undefined') {
+                  throw new Error(`input '${name}' is missing in 'feeds'.`);
+              }
           }
-          // perform check
-          const size = calculateSize(dims);
-          if (size !== data.length) {
-              throw new Error(`Tensor's size(${size}) does not match data length(${data.length}).`);
+          // if no fetches is specified, we use the full output names list
+          if (isFetchesEmpty) {
+              for (const name of this.outputNames) {
+                  fetches[name] = null;
+              }
           }
-          this.dims = dims;
-          this.type = type;
-          this.data = data;
-          this.size = size;
-      }
-      // #endregion
-      /**
-       * Create a new tensor object from image object
-       *
-       * @param buffer - Extracted image buffer data - assuming RGBA format
-       * @param imageFormat - input image configuration - required configurations height, width, format
-       * @param tensorFormat - output tensor configuration - Default is RGB format
-       */
-      static bufferToTensor(buffer, options) {
-          if (buffer === undefined) {
-              throw new Error('Image buffer must be defined');
+          // feeds, fetches and options are prepared
+          const results = await this.handler.run(feeds, fetches, options);
+          const returnValue = {};
+          for (const key in results) {
+              if (Object.hasOwnProperty.call(results, key)) {
+                  returnValue[key] = new Tensor(results[key].type, results[key].data, results[key].dims);
+              }
           }
-          if (options.height === undefined || options.width === undefined) {
-              throw new Error('Image height and width must be defined');
-          }
-          const { height, width } = options;
-          const norm = options.norm;
-          let normMean;
-          let normBias;
-          if (norm === undefined || norm.mean === undefined) {
-              normMean = 255;
-          }
-          else {
-              normMean = norm.mean;
-          }
-          if (norm === undefined || norm.bias === undefined) {
-              normBias = 0;
-          }
-          else {
-              normBias = norm.bias;
-          }
-          const inputformat = options.bitmapFormat !== undefined ? options.bitmapFormat : 'RGBA';
-          // default value is RGBA since imagedata and HTMLImageElement uses it
-          const outputformat = options.tensorFormat !== undefined ?
-              (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') :
-              'RGB';
-          const offset = height * width;
-          const float32Data = outputformat === 'RGBA' ? new Float32Array(offset * 4) : new Float32Array(offset * 3);
-          // Default pointer assignments
-          let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
-          let rTensorPointer = 0, gTensorPointer = offset, bTensorPointer = offset * 2, aTensorPointer = -1;
-          // Updating the pointer assignments based on the input image format
-          if (inputformat === 'RGB') {
-              step = 3;
-              rImagePointer = 0;
-              gImagePointer = 1;
-              bImagePointer = 2;
-              aImagePointer = -1;
-          }
-          // Updating the pointer assignments based on the output tensor format
-          if (outputformat === 'RGBA') {
-              aTensorPointer = offset * 3;
-          }
-          else if (outputformat === 'RBG') {
-              rTensorPointer = 0;
-              bTensorPointer = offset;
-              gTensorPointer = offset * 2;
-          }
-          else if (outputformat === 'BGR') {
-              bTensorPointer = 0;
-              gTensorPointer = offset;
-              rTensorPointer = offset * 2;
-          }
-          for (let i = 0; i < offset; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
-              float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias) / normMean;
-              float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias) / normMean;
-              float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias) / normMean;
-              if (aTensorPointer !== -1 && aImagePointer !== -1) {
-                  float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias) / normMean;
-              }
-          }
-          // Float32Array -> ort.Tensor
-          const outputTensor = outputformat === 'RGBA' ? new Tensor('float32', float32Data, [1, 4, height, width]) :
-              new Tensor('float32', float32Data, [1, 3, height, width]);
-          return outputTensor;
+          return returnValue;
       }
-      static async fromImage(image, options) {
-          // checking the type of image object
-          const isHTMLImageEle = typeof (HTMLImageElement) !== 'undefined' && image instanceof HTMLImageElement;
-          const isImageDataEle = typeof (ImageData) !== 'undefined' && image instanceof ImageData;
-          const isImageBitmap = typeof (ImageBitmap) !== 'undefined' && image instanceof ImageBitmap;
-          const isURL = typeof (String) !== 'undefined' && (image instanceof String || typeof image === 'string');
-          let data;
-          let tensorConfig = {};
-          // filling and checking image configuration options
-          if (isHTMLImageEle) {
-              // HTMLImageElement - image object - format is RGBA by default
-              const canvas = document.createElement('canvas');
-              const pixels2DContext = canvas.getContext('2d');
-              if (pixels2DContext != null) {
-                  let height = image.naturalHeight;
-                  let width = image.naturalWidth;
-                  if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {
-                      height = options.resizedHeight;
-                      width = options.resizedWidth;
-                  }
-                  if (options !== undefined) {
-                      tensorConfig = options;
-                      if (options.tensorFormat !== undefined) {
-                          throw new Error('Image input config format must be RGBA for HTMLImageElement');
-                      }
-                      else {
-                          tensorConfig.tensorFormat = 'RGBA';
-                      }
-                      if (options.height !== undefined && options.height !== height) {
-                          throw new Error('Image input config height doesn\'t match HTMLImageElement height');
-                      }
-                      else {
-                          tensorConfig.height = height;
-                      }
-                      if (options.width !== undefined && options.width !== width) {
-                          throw new Error('Image input config width doesn\'t match HTMLImageElement width');
-                      }
-                      else {
-                          tensorConfig.width = width;
-                      }
-                  }
-                  else {
-                      tensorConfig.tensorFormat = 'RGBA';
-                      tensorConfig.height = height;
-                      tensorConfig.width = width;
-                  }
-                  canvas.width = width;
-                  canvas.height = height;
-                  pixels2DContext.drawImage(image, 0, 0, width, height);
-                  data = pixels2DContext.getImageData(0, 0, width, height).data;
+      static async create(arg0, arg1, arg2, arg3) {
+          // either load from a file or buffer
+          let filePathOrUint8Array;
+          let options = {};
+          if (typeof arg0 === 'string') {
+              filePathOrUint8Array = arg0;
+              if (typeof arg1 === 'object' && arg1 !== null) {
+                  options = arg1;
               }
-              else {
-                  throw new Error('Can not access image data');
+              else if (typeof arg1 !== 'undefined') {
+                  throw new TypeError('\'options\' must be an object.');
               }
           }
-          else if (isImageDataEle) {
-              // ImageData - image object - format is RGBA by default
-              const format = 'RGBA';
-              let height;
-              let width;
-              if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {
-                  height = options.resizedHeight;
-                  width = options.resizedWidth;
-              }
-              else {
-                  height = image.height;
-                  width = image.width;
+          else if (arg0 instanceof Uint8Array) {
+              filePathOrUint8Array = arg0;
+              if (typeof arg1 === 'object' && arg1 !== null) {
+                  options = arg1;
               }
-              if (options !== undefined) {
-                  tensorConfig = options;
-                  if (options.bitmapFormat !== undefined && options.bitmapFormat !== format) {
-                      throw new Error('Image input config format must be RGBA for ImageData');
-                  }
-                  else {
-                      tensorConfig.bitmapFormat = 'RGBA';
-                  }
+              else if (typeof arg1 !== 'undefined') {
+                  throw new TypeError('\'options\' must be an object.');
               }
-              else {
-                  tensorConfig.bitmapFormat = 'RGBA';
+          }
+          else if (arg0 instanceof ArrayBuffer ||
+              (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)) {
+              const buffer = arg0;
+              let byteOffset = 0;
+              let byteLength = arg0.byteLength;
+              if (typeof arg1 === 'object' && arg1 !== null) {
+                  options = arg1;
               }
-              tensorConfig.height = height;
-              tensorConfig.width = width;
-              if (options !== undefined) {
-                  const tempCanvas = document.createElement('canvas');
-                  tempCanvas.width = width;
-                  tempCanvas.height = height;
-                  const pixels2DContext = tempCanvas.getContext('2d');
-                  if (pixels2DContext != null) {
-                      pixels2DContext.putImageData(image, 0, 0);
-                      data = pixels2DContext.getImageData(0, 0, width, height).data;
+              else if (typeof arg1 === 'number') {
+                  byteOffset = arg1;
+                  if (!Number.isSafeInteger(byteOffset)) {
+                      throw new RangeError('\'byteOffset\' must be an integer.');
                   }
-                  else {
-                      throw new Error('Can not access image data');
+                  if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
+                      throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
                   }
-              }
-              else {
-                  data = image.data;
-              }
-          }
-          else if (isImageBitmap) {
-              // ImageBitmap - image object - format must be provided by user
-              if (options === undefined) {
-                  throw new Error('Please provide image config with format for Imagebitmap');
-              }
-              if (options.bitmapFormat !== undefined) {
-                  throw new Error('Image input config format must be defined for ImageBitmap');
-              }
-              const pixels2DContext = document.createElement('canvas').getContext('2d');
-              if (pixels2DContext != null) {
-                  const height = image.height;
-                  const width = image.width;
-                  pixels2DContext.drawImage(image, 0, 0, width, height);
-                  data = pixels2DContext.getImageData(0, 0, width, height).data;
-                  if (options !== undefined) {
-                      // using square brackets to avoid TS error - type 'never'
-                      if (options.height !== undefined && options.height !== height) {
-                          throw new Error('Image input config height doesn\'t match ImageBitmap height');
+                  byteLength = arg0.byteLength - byteOffset;
+                  if (typeof arg2 === 'number') {
+                      byteLength = arg2;
+                      if (!Number.isSafeInteger(byteLength)) {
+                          throw new RangeError('\'byteLength\' must be an integer.');
                       }
-                      else {
-                          tensorConfig.height = height;
+                      if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
+                          throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
                       }
-                      // using square brackets to avoid TS error - type 'never'
-                      if (options.width !== undefined && options.width !== width) {
-                          throw new Error('Image input config width doesn\'t match ImageBitmap width');
+                      if (typeof arg3 === 'object' && arg3 !== null) {
+                          options = arg3;
                       }
-                      else {
-                          tensorConfig.width = width;
+                      else if (typeof arg3 !== 'undefined') {
+                          throw new TypeError('\'options\' must be an object.');
                       }
                   }
-                  else {
-                      tensorConfig.height = height;
-                      tensorConfig.width = width;
+                  else if (typeof arg2 !== 'undefined') {
+                      throw new TypeError('\'byteLength\' must be a number.');
                   }
-                  return Tensor.bufferToTensor(data, tensorConfig);
               }
-              else {
-                  throw new Error('Can not access image data');
+              else if (typeof arg1 !== 'undefined') {
+                  throw new TypeError('\'options\' must be an object.');
               }
-          }
-          else if (isURL) {
-              return new Promise((resolve, reject) => {
-                  const canvas = document.createElement('canvas');
-                  const context = canvas.getContext('2d');
-                  if (!image || !context) {
-                      return reject();
-                  }
-                  const newImage = new Image();
-                  newImage.crossOrigin = 'Anonymous';
-                  newImage.src = image;
-                  newImage.onload = () => {
-                      canvas.width = newImage.width;
-                      canvas.height = newImage.height;
-                      context.drawImage(newImage, 0, 0, canvas.width, canvas.height);
-                      const img = context.getImageData(0, 0, canvas.width, canvas.height);
-                      if (options !== undefined) {
-                          // using square brackets to avoid TS error - type 'never'
-                          if (options.height !== undefined && options.height !== canvas.height) {
-                              throw new Error('Image input config height doesn\'t match ImageBitmap height');
-                          }
-                          else {
-                              tensorConfig.height = canvas.height;
-                          }
-                          // using square brackets to avoid TS error - type 'never'
-                          if (options.width !== undefined && options.width !== canvas.width) {
-                              throw new Error('Image input config width doesn\'t match ImageBitmap width');
-                          }
-                          else {
-                              tensorConfig.width = canvas.width;
-                          }
-                      }
-                      else {
-                          tensorConfig.height = canvas.height;
-                          tensorConfig.width = canvas.width;
-                      }
-                      resolve(Tensor.bufferToTensor(img.data, tensorConfig));
-                  };
-              });
-          }
-          else {
-              throw new Error('Input data provided is not supported - aborted tensor creation');
-          }
-          if (data !== undefined) {
-              return Tensor.bufferToTensor(data, tensorConfig);
-          }
-          else {
-              throw new Error('Input data provided is not supported - aborted tensor creation');
-          }
-      }
-      toImageData(options) {
-          var _a, _b;
-          const pixels2DContext = document.createElement('canvas').getContext('2d');
-          let image;
-          if (pixels2DContext != null) {
-              // Default values for height and width & format
-              const width = this.dims[3];
-              const height = this.dims[2];
-              const channels = this.dims[1];
-              const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';
-              const normMean = options !== undefined ? (((_a = options.norm) === null || _a === void 0 ? void 0 : _a.mean) !== undefined ? options.norm.mean : 255) : 255;
-              const normBias = options !== undefined ? (((_b = options.norm) === null || _b === void 0 ? void 0 : _b.bias) !== undefined ? options.norm.bias : 0) : 0;
-              const offset = height * width;
-              if (options !== undefined) {
-                  if (options.height !== undefined && options.height !== height) {
-                      throw new Error('Image output config height doesn\'t match tensor height');
-                  }
-                  if (options.width !== undefined && options.width !== width) {
-                      throw new Error('Image output config width doesn\'t match tensor width');
-                  }
-                  if (options.format !== undefined && (channels === 4 && options.format !== 'RGBA') ||
-                      (channels === 3 && (options.format !== 'RGB' && options.format !== 'BGR'))) {
-                      throw new Error('Tensor format doesn\'t match input tensor dims');
-                  }
-              }
-              // Default pointer assignments
-              const step = 4;
-              let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
-              let rTensorPointer = 0, gTensorPointer = offset, bTensorPointer = offset * 2, aTensorPointer = -1;
-              // Updating the pointer assignments based on the input image format
-              if (inputformat === 'RGBA') {
-                  rTensorPointer = 0;
-                  gTensorPointer = offset;
-                  bTensorPointer = offset * 2;
-                  aTensorPointer = offset * 3;
-              }
-              else if (inputformat === 'RGB') {
-                  rTensorPointer = 0;
-                  gTensorPointer = offset;
-                  bTensorPointer = offset * 2;
-              }
-              else if (inputformat === 'RBG') {
-                  rTensorPointer = 0;
-                  bTensorPointer = offset;
-                  gTensorPointer = offset * 2;
-              }
-              image = pixels2DContext.createImageData(width, height);
-              for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
-                  image.data[rImagePointer] = (this.data[rTensorPointer++] - normBias) * normMean; // R value
-                  image.data[gImagePointer] = (this.data[gTensorPointer++] - normBias) * normMean; // G value
-                  image.data[bImagePointer] = (this.data[bTensorPointer++] - normBias) * normMean; // B value
-                  image.data[aImagePointer] =
-                      aTensorPointer === -1 ? 255 : (this.data[aTensorPointer++] - normBias) * normMean; // A value
-              }
-          }
-          else {
-              throw new Error('Can not access image data');
-          }
-          return image;
-      }
-      // #endregion
-      // #region tensor utilities
-      reshape(dims) {
-          return new Tensor(this.type, this.data, dims);
-      }
-  };
-
-  // Copyright (c) Microsoft Corporation. All rights reserved.
-  // Licensed under the MIT License.
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const Tensor = Tensor$1;
-
-  // Copyright (c) Microsoft Corporation. All rights reserved.
-  // Licensed under the MIT License.
-  let InferenceSession$1 = class InferenceSession {
-      constructor(handler) {
-          this.handler = handler;
-      }
-      async run(feeds, arg1, arg2) {
-          const fetches = {};
-          let options = {};
-          // check inputs
-          if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {
-              throw new TypeError('\'feeds\' must be an object that use input names as keys and OnnxValue as corresponding values.');
-          }
-          let isFetchesEmpty = true;
-          // determine which override is being used
-          if (typeof arg1 === 'object') {
-              if (arg1 === null) {
-                  throw new TypeError('Unexpected argument[1]: cannot be null.');
-              }
-              if (arg1 instanceof Tensor) {
-                  throw new TypeError('\'fetches\' cannot be a Tensor');
-              }
-              if (Array.isArray(arg1)) {
-                  if (arg1.length === 0) {
-                      throw new TypeError('\'fetches\' cannot be an empty array.');
-                  }
-                  isFetchesEmpty = false;
-                  // output names
-                  for (const name of arg1) {
-                      if (typeof name !== 'string') {
-                          throw new TypeError('\'fetches\' must be a string array or an object.');
-                      }
-                      if (this.outputNames.indexOf(name) === -1) {
-                          throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
-                      }
-                      fetches[name] = null;
-                  }
-                  if (typeof arg2 === 'object' && arg2 !== null) {
-                      options = arg2;
-                  }
-                  else if (typeof arg2 !== 'undefined') {
-                      throw new TypeError('\'options\' must be an object.');
-                  }
-              }
-              else {
-                  // decide whether arg1 is fetches or options
-                  // if any output name is present and its value is valid OnnxValue, we consider it fetches
-                  let isFetches = false;
-                  const arg1Keys = Object.getOwnPropertyNames(arg1);
-                  for (const name of this.outputNames) {
-                      if (arg1Keys.indexOf(name) !== -1) {
-                          const v = arg1[name];
-                          if (v === null || v instanceof Tensor) {
-                              isFetches = true;
-                              isFetchesEmpty = false;
-                              fetches[name] = v;
-                          }
-                      }
-                  }
-                  if (isFetches) {
-                      if (typeof arg2 === 'object' && arg2 !== null) {
-                          options = arg2;
-                      }
-                      else if (typeof arg2 !== 'undefined') {
-                          throw new TypeError('\'options\' must be an object.');
-                      }
-                  }
-                  else {
-                      options = arg1;
-                  }
-              }
-          }
-          else if (typeof arg1 !== 'undefined') {
-              throw new TypeError('Unexpected argument[1]: must be \'fetches\' or \'options\'.');
-          }
-          // check if all inputs are in feed
-          for (const name of this.inputNames) {
-              if (typeof feeds[name] === 'undefined') {
-                  throw new Error(`input '${name}' is missing in 'feeds'.`);
-              }
-          }
-          // if no fetches is specified, we use the full output names list
-          if (isFetchesEmpty) {
-              for (const name of this.outputNames) {
-                  fetches[name] = null;
-              }
-          }
-          // feeds, fetches and options are prepared
-          const results = await this.handler.run(feeds, fetches, options);
-          const returnValue = {};
-          for (const key in results) {
-              if (Object.hasOwnProperty.call(results, key)) {
-                  returnValue[key] = new Tensor(results[key].type, results[key].data, results[key].dims);
-              }
-          }
-          return returnValue;
-      }
-      static async create(arg0, arg1, arg2, arg3) {
-          // either load from a file or buffer
-          let filePathOrUint8Array;
-          let options = {};
-          if (typeof arg0 === 'string') {
-              filePathOrUint8Array = arg0;
-              if (typeof arg1 === 'object' && arg1 !== null) {
-                  options = arg1;
-              }
-              else if (typeof arg1 !== 'undefined') {
-                  throw new TypeError('\'options\' must be an object.');
-              }
-          }
-          else if (arg0 instanceof Uint8Array) {
-              filePathOrUint8Array = arg0;
-              if (typeof arg1 === 'object' && arg1 !== null) {
-                  options = arg1;
-              }
-              else if (typeof arg1 !== 'undefined') {
-                  throw new TypeError('\'options\' must be an object.');
-              }
-          }
-          else if (arg0 instanceof ArrayBuffer ||
-              (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)) {
-              const buffer = arg0;
-              let byteOffset = 0;
-              let byteLength = arg0.byteLength;
-              if (typeof arg1 === 'object' && arg1 !== null) {
-                  options = arg1;
-              }
-              else if (typeof arg1 === 'number') {
-                  byteOffset = arg1;
-                  if (!Number.isSafeInteger(byteOffset)) {
-                      throw new RangeError('\'byteOffset\' must be an integer.');
-                  }
-                  if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
-                      throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
-                  }
-                  byteLength = arg0.byteLength - byteOffset;
-                  if (typeof arg2 === 'number') {
-                      byteLength = arg2;
-                      if (!Number.isSafeInteger(byteLength)) {
-                          throw new RangeError('\'byteLength\' must be an integer.');
-                      }
-                      if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
-                          throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
-                      }
-                      if (typeof arg3 === 'object' && arg3 !== null) {
-                          options = arg3;
-                      }
-                      else if (typeof arg3 !== 'undefined') {
-                          throw new TypeError('\'options\' must be an object.');
-                      }
-                  }
-                  else if (typeof arg2 !== 'undefined') {
-                      throw new TypeError('\'byteLength\' must be a number.');
-                  }
-              }
-              else if (typeof arg1 !== 'undefined') {
-                  throw new TypeError('\'options\' must be an object.');
-              }
-              filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);
+              filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);
           }
           else {
               throw new TypeError('Unexpected argument[0]: must be \'path\' or \'buffer\'.');
@@ -3947,7 +3147,7 @@ registerProcessor('audio_processor', AudioProcessor);
       return Math.ceil((targetDuration * sr) / 1000 / frameSamples);
   }
   utils.minFramesForTargetMS = minFramesForTargetMS;
-  function arrayBufferToBase64(buffer) {
+  function arrayBufferToBase64$1(buffer) {
       const bytes = new Uint8Array(buffer);
       const len = bytes.byteLength;
       const binary = new Array(len);
@@ -3960,7 +3160,7 @@ registerProcessor('audio_processor', AudioProcessor);
       }
       return btoa(binary.join(""));
   }
-  utils.arrayBufferToBase64 = arrayBufferToBase64;
+  utils.arrayBufferToBase64 = arrayBufferToBase64$1;
   /*
   This rest of this was mostly copied from https://github.com/linto-ai/WebVoiceSDK
   */
@@ -4379,12 +3579,736 @@ registerProcessor('audio_processor', AudioProcessor);
   	
   } (dist));
 
-  var index = /*@__PURE__*/getDefaultExportFromCjs(dist);
-
-  var index$1 = /*#__PURE__*/_mergeNamespaces({
-    __proto__: null,
-    default: index
-  }, [dist]);
+  /**
+   * Converts a base64 string to an ArrayBuffer.
+   * @param {string} base64 - The base64 string to convert.
+   * @returns {ArrayBuffer} The resulting ArrayBuffer.
+   */
+  function base64ToArrayBuffer(base64) {
+    const binaryString = atob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+
+  /**
+   * Converts an ArrayBuffer to a base64 string.
+   * @param {ArrayBuffer|Float32Array|Int16Array} arrayBuffer - The ArrayBuffer to convert.
+   * @returns {string} The resulting base64 string.
+   */
+  function arrayBufferToBase64(arrayBuffer) {
+    if (arrayBuffer instanceof Float32Array) {
+      arrayBuffer = this.floatTo16BitPCM(arrayBuffer);
+    } else if (arrayBuffer instanceof Int16Array) {
+      arrayBuffer = arrayBuffer.buffer;
+    }
+    let binary = '';
+    let bytes = new Uint8Array(arrayBuffer);
+    const chunkSize = 0x8000; // 32KB chunk size
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      let chunk = bytes.subarray(i, i + chunkSize);
+      binary += String.fromCharCode.apply(null, chunk);
+    }
+    return btoa(binary);
+  }
+
+  /* eslint-env browser */
+  // import { env as ortEnv } from 'onnxruntime-web';
+  const NOOP = () => { };
+  const DEFAULT_WS_URL = 'wss://api.layercode.com/v1/agents/web/websocket';
+  // SDK version - updated when publishing
+  const SDK_VERSION = '2.1.3';
+  /**
+   * @class LayercodeClient
+   * @classdesc Core client for Layercode audio agent that manages audio recording, WebSocket communication, and speech processing.
+   */
+  class LayercodeClient {
+      /**
+       * Creates an instance of LayercodeClient.
+       * @param {Object} options - Configuration options
+       */
+      constructor(options) {
+          var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+          this.deviceId = null;
+          this.options = {
+              agentId: options.agentId,
+              conversationId: (_a = options.conversationId) !== null && _a !== void 0 ? _a : null,
+              authorizeSessionEndpoint: options.authorizeSessionEndpoint,
+              metadata: (_b = options.metadata) !== null && _b !== void 0 ? _b : {},
+              vadResumeDelay: (_c = options.vadResumeDelay) !== null && _c !== void 0 ? _c : 500,
+              onConnect: (_d = options.onConnect) !== null && _d !== void 0 ? _d : NOOP,
+              onDisconnect: (_e = options.onDisconnect) !== null && _e !== void 0 ? _e : NOOP,
+              onError: (_f = options.onError) !== null && _f !== void 0 ? _f : NOOP,
+              onDeviceSwitched: (_g = options.onDeviceSwitched) !== null && _g !== void 0 ? _g : NOOP,
+              onDevicesChanged: (_h = options.onDevicesChanged) !== null && _h !== void 0 ? _h : NOOP,
+              onDataMessage: (_j = options.onDataMessage) !== null && _j !== void 0 ? _j : NOOP,
+              onMessage: (_k = options.onMessage) !== null && _k !== void 0 ? _k : NOOP,
+              onUserAmplitudeChange: (_l = options.onUserAmplitudeChange) !== null && _l !== void 0 ? _l : NOOP,
+              onAgentAmplitudeChange: (_m = options.onAgentAmplitudeChange) !== null && _m !== void 0 ? _m : NOOP,
+              onStatusChange: (_o = options.onStatusChange) !== null && _o !== void 0 ? _o : NOOP,
+              onUserIsSpeakingChange: (_p = options.onUserIsSpeakingChange) !== null && _p !== void 0 ? _p : NOOP,
+              onMuteStateChange: (_q = options.onMuteStateChange) !== null && _q !== void 0 ? _q : NOOP,
+          };
+          this.AMPLITUDE_MONITORING_SAMPLE_RATE = 2;
+          this._websocketUrl = DEFAULT_WS_URL;
+          this.wavRecorder = new WavRecorder({ sampleRate: 8000 }); // TODO should be set my fetched agent config
+          this.wavPlayer = new WavStreamPlayer({
+              finishedPlayingCallback: this._clientResponseAudioReplayFinished.bind(this),
+              sampleRate: 16000, // TODO should be set my fetched agent config
+          });
+          this.vad = null;
+          this.ws = null;
+          this.status = 'disconnected';
+          this.userAudioAmplitude = 0;
+          this.agentAudioAmplitude = 0;
+          this.conversationId = this.options.conversationId;
+          this.pushToTalkActive = false;
+          this.pushToTalkEnabled = false;
+          this.canInterrupt = false;
+          this.userIsSpeaking = false;
+          this.recorderStarted = false;
+          this.readySent = false;
+          this.currentTurnId = null;
+          this.audioBuffer = [];
+          this.vadConfig = null;
+          this.activeDeviceId = null;
+          this.useSystemDefaultDevice = false;
+          this.lastReportedDeviceId = null;
+          this.lastKnownSystemDefaultDeviceKey = null;
+          this.isMuted = false;
+          this.stopPlayerAmplitude = undefined;
+          this.stopRecorderAmplitude = undefined;
+          this.deviceChangeListener = null;
+          // this.audioPauseTime = null;
+          // Bind event handlers
+          this._handleWebSocketMessage = this._handleWebSocketMessage.bind(this);
+          this._handleDataAvailable = this._handleDataAvailable.bind(this);
+      }
+      _initializeVAD() {
+          var _a;
+          console.log('initializing VAD', { pushToTalkEnabled: this.pushToTalkEnabled, canInterrupt: this.canInterrupt, vadConfig: this.vadConfig });
+          // If we're in push to talk mode, we don't need to use the VAD model
+          if (this.pushToTalkEnabled) {
+              return;
+          }
+          // Check if VAD is disabled
+          if (((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) === false) {
+              console.log('VAD is disabled by backend configuration');
+              return;
+          }
+          // Build VAD configuration object, only including keys that are defined
+          const vadOptions = {
+              stream: this.wavRecorder.getStream() || undefined,
+              onSpeechStart: () => {
+                  console.debug('onSpeechStart: sending vad_start');
+                  this.userIsSpeaking = true;
+                  this.options.onUserIsSpeakingChange(true);
+                  this._wsSend({
+                      type: 'vad_events',
+                      event: 'vad_start',
+                  });
+                  this.options.onMessage({
+                      type: 'vad_events',
+                      event: 'vad_start',
+                  });
+              },
+              onSpeechEnd: () => {
+                  console.debug('onSpeechEnd: sending vad_end');
+                  this.userIsSpeaking = false;
+                  this.options.onUserIsSpeakingChange(false);
+                  this.audioBuffer = []; // Clear buffer on speech end
+                  this._wsSend({
+                      type: 'vad_events',
+                      event: 'vad_end',
+                  });
+                  this.options.onMessage({
+                      type: 'vad_events',
+                      event: 'vad_end',
+                  });
+              },
+          };
+          // Apply VAD configuration from backend if available
+          if (this.vadConfig) {
+              // Only add keys that are explicitly defined (not undefined)
+              if (this.vadConfig.model !== undefined)
+                  vadOptions.model = this.vadConfig.model;
+              if (this.vadConfig.positive_speech_threshold !== undefined)
+                  vadOptions.positiveSpeechThreshold = this.vadConfig.positive_speech_threshold;
+              if (this.vadConfig.negative_speech_threshold !== undefined)
+                  vadOptions.negativeSpeechThreshold = this.vadConfig.negative_speech_threshold;
+              if (this.vadConfig.redemption_frames !== undefined)
+                  vadOptions.redemptionFrames = this.vadConfig.redemption_frames;
+              if (this.vadConfig.min_speech_frames !== undefined)
+                  vadOptions.minSpeechFrames = this.vadConfig.min_speech_frames;
+              if (this.vadConfig.pre_speech_pad_frames !== undefined)
+                  vadOptions.preSpeechPadFrames = this.vadConfig.pre_speech_pad_frames;
+              if (this.vadConfig.frame_samples !== undefined)
+                  vadOptions.frameSamples = this.vadConfig.frame_samples;
+          }
+          else {
+              // Default values if no config from backend
+              vadOptions.model = 'v5';
+              vadOptions.positiveSpeechThreshold = 0.15;
+              vadOptions.negativeSpeechThreshold = 0.05;
+              vadOptions.redemptionFrames = 4;
+              vadOptions.minSpeechFrames = 2;
+              vadOptions.preSpeechPadFrames = 0;
+              vadOptions.frameSamples = 512; // Required for v5
+          }
+          console.log('Creating VAD with options:', vadOptions);
+          dist.MicVAD.new(vadOptions)
+              .then((vad) => {
+              this.vad = vad;
+              this.vad.start();
+              console.log('VAD started successfully');
+          })
+              .catch((error) => {
+              console.warn('Error initializing VAD:', error);
+              // Send a message to server indicating VAD failure
+              this._wsSend({
+                  type: 'vad_events',
+                  event: 'vad_model_failed',
+              });
+          });
+      }
+      /**
+       * Updates the connection status and triggers the callback
+       * @param {string} status - New status value
+       */
+      _setStatus(status) {
+          this.status = status;
+          this.options.onStatusChange(status);
+      }
+      /**
+       * Handles when agent audio finishes playing
+       */
+      _clientResponseAudioReplayFinished() {
+          console.debug('clientResponseAudioReplayFinished');
+          this._wsSend({
+              type: 'trigger.response.audio.replay_finished',
+              reason: 'completed',
+          });
+      }
+      async _clientInterruptAssistantReplay() {
+          await this.wavPlayer.interrupt();
+      }
+      async triggerUserTurnStarted() {
+          if (!this.pushToTalkActive) {
+              this.pushToTalkActive = true;
+              this._wsSend({ type: 'trigger.turn.start', role: 'user' });
+              await this._clientInterruptAssistantReplay();
+          }
+      }
+      async triggerUserTurnFinished() {
+          if (this.pushToTalkActive) {
+              this.pushToTalkActive = false;
+              this._wsSend({ type: 'trigger.turn.end', role: 'user' });
+          }
+      }
+      /**
+       * Handles incoming WebSocket messages
+       * @param {MessageEvent} event - The WebSocket message event
+       */
+      async _handleWebSocketMessage(event) {
+          try {
+              const message = JSON.parse(event.data);
+              if (message.type !== 'response.audio') {
+                  console.debug('msg:', message);
+              }
+              switch (message.type) {
+                  case 'turn.start':
+                      // Sent from the server to this client when a new user turn is detected
+                      if (message.role === 'assistant') {
+                          // Start tracking new assistant turn
+                          console.debug('Assistant turn started, will track new turn ID from audio/text');
+                      }
+                      else if (message.role === 'user' && !this.pushToTalkEnabled) {
+                          // Interrupt any playing assistant audio if this is a turn triggered by the server (and not push to talk, which will have already called interrupt)
+                          console.debug('interrupting assistant audio, as user turn has started and pushToTalkEnabled is false');
+                          await this._clientInterruptAssistantReplay();
+                      }
+                      this.options.onMessage(message);
+                      break;
+                  case 'response.audio':
+                      const audioBuffer = base64ToArrayBuffer(message.content);
+                      this.wavPlayer.add16BitPCM(audioBuffer, message.turn_id);
+                      // TODO: once we've added turn_id to the turn.start msgs sent from teh server, we should move this currentTurnId switching logic to the turn.start msg case. We can then remove the currentTurnId setting logic from the response.audio and response.text cases.
+                      // Set current turn ID from first audio message, or update if different turn
+                      if (!this.currentTurnId || this.currentTurnId !== message.turn_id) {
+                          console.debug(`Setting current turn ID to: ${message.turn_id} (was: ${this.currentTurnId})`);
+                          this.currentTurnId = message.turn_id;
+                          // Clean up interrupted tracks, keeping only the current turn
+                          this.wavPlayer.clearInterruptedTracks(this.currentTurnId ? [this.currentTurnId] : []);
+                      }
+                      break;
+                  case 'response.text':
+                      // Set turn ID from first text message if not set
+                      if (!this.currentTurnId) {
+                          this.currentTurnId = message.turn_id;
+                          console.debug(`Setting current turn ID to: ${message.turn_id} from text message`);
+                      }
+                      this.options.onMessage(message);
+                      break;
+                  case 'response.data':
+                      this.options.onDataMessage(message);
+                      break;
+                  case 'user.transcript':
+                  case 'user.transcript.delta':
+                  case 'user.transcript.interim_delta':
+                      this.options.onMessage(message);
+                      break;
+                  default:
+                      console.warn('Unknown message type received:', message);
+              }
+          }
+          catch (error) {
+              console.error('Error processing WebSocket message:', error);
+              this.options.onError(error instanceof Error ? error : new Error(String(error)));
+          }
+      }
+      /**
+       * Handles available client browser microphone audio data and sends it over the WebSocket
+       * @param {ArrayBuffer} data - The audio data buffer
+       */
+      _handleDataAvailable(data) {
+          var _a, _b, _c;
+          try {
+              const base64 = arrayBufferToBase64(data.mono);
+              // Don't send audio if muted
+              if (this.isMuted) {
+                  return;
+              }
+              // Determine if we should gate audio based on VAD configuration
+              const shouldGateAudio = ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.gate_audio) !== false; // Default to true if not specified
+              const bufferFrames = (_c = (_b = this.vadConfig) === null || _b === void 0 ? void 0 : _b.buffer_frames) !== null && _c !== void 0 ? _c : 10; // Default to 10 if not specified
+              let sendAudio;
+              if (this.pushToTalkEnabled) {
+                  sendAudio = this.pushToTalkActive;
+              }
+              else if (shouldGateAudio) {
+                  sendAudio = this.userIsSpeaking;
+              }
+              else {
+                  // If gate_audio is false, always send audio
+                  sendAudio = true;
+              }
+              if (sendAudio) {
+                  // If we have buffered audio and we're gating, send it first
+                  if (shouldGateAudio && this.audioBuffer.length > 0) {
+                      console.debug(`Sending ${this.audioBuffer.length} buffered audio chunks`);
+                      for (const bufferedAudio of this.audioBuffer) {
+                          this._wsSend({
+                              type: 'client.audio',
+                              content: bufferedAudio,
+                          });
+                      }
+                      this.audioBuffer = []; // Clear the buffer after sending
+                  }
+                  // Send the current audio
+                  this._wsSend({
+                      type: 'client.audio',
+                      content: base64,
+                  });
+              }
+              else {
+                  // Buffer audio when not sending (to catch audio just before VAD triggers)
+                  this.audioBuffer.push(base64);
+                  // Keep buffer size based on configuration
+                  if (this.audioBuffer.length > bufferFrames) {
+                      this.audioBuffer.shift(); // Remove oldest chunk
+                  }
+              }
+          }
+          catch (error) {
+              console.error('Error processing audio:', error);
+              this.options.onError(error instanceof Error ? error : new Error(String(error)));
+          }
+      }
+      _wsSend(message) {
+          var _a;
+          if (message.type !== 'client.audio') {
+              console.debug('sent_msg:', message);
+          }
+          const messageString = JSON.stringify(message);
+          if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+              this.ws.send(messageString);
+          }
+      }
+      _sendReadyIfNeeded() {
+          var _a;
+          if (this.recorderStarted && ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN && !this.readySent) {
+              this._wsSend({ type: 'client.ready' });
+              this.readySent = true;
+          }
+      }
+      /**
+       * Sets up amplitude monitoring for a given audio source.
+       * @param {WavRecorder | WavStreamPlayer} source - The audio source (recorder or player).
+       * @param {(amplitude: number) => void} callback - The callback function to invoke on amplitude change.
+       * @param {(amplitude: number) => void} updateInternalState - Function to update the internal amplitude state.
+       */
+      _setupAmplitudeMonitoring(source, callback, updateInternalState) {
+          let updateCounter = 0;
+          source.startAmplitudeMonitoring((amplitude) => {
+              // Only update and call callback at the specified sample rate
+              if (updateCounter >= this.AMPLITUDE_MONITORING_SAMPLE_RATE) {
+                  updateInternalState(amplitude);
+                  if (callback !== NOOP) {
+                      callback(amplitude);
+                  }
+                  updateCounter = 0; // Reset counter after sampling
+              }
+              updateCounter++;
+          });
+          const stop = () => { var _a; return (_a = source.stopAmplitudeMonitoring) === null || _a === void 0 ? void 0 : _a.call(source); };
+          if (source === this.wavPlayer) {
+              this.stopPlayerAmplitude = stop;
+          }
+          if (source === this.wavRecorder) {
+              this.stopRecorderAmplitude = stop;
+          }
+      }
+      _stopAmplitudeMonitoring() {
+          var _a, _b;
+          (_a = this.stopPlayerAmplitude) === null || _a === void 0 ? void 0 : _a.call(this);
+          (_b = this.stopRecorderAmplitude) === null || _b === void 0 ? void 0 : _b.call(this);
+          this.stopPlayerAmplitude = undefined;
+          this.stopRecorderAmplitude = undefined;
+      }
+      /**
+       * Connects to the Layercode agent using the stored conversation ID and starts the audio conversation
+       * @async
+       * @returns {Promise<void>}
+       */
+      async connect() {
+          if (this.status === 'connecting') {
+              return;
+          }
+          try {
+              this._setStatus('connecting');
+              // Reset turn tracking for clean start
+              this._resetTurnTracking();
+              this._stopAmplitudeMonitoring();
+              // Get conversation key from server
+              let authorizeSessionRequestBody = {
+                  agent_id: this.options.agentId,
+                  metadata: this.options.metadata,
+                  sdk_version: SDK_VERSION,
+              };
+              // If we're reconnecting to a previous conversation, we need to include the conversation_id in the request. Otherwise we don't send conversation_id, and a new conversation will be created and the conversation_id will be returned in the response.
+              if (this.options.conversationId) {
+                  authorizeSessionRequestBody.conversation_id = this.options.conversationId;
+              }
+              const authorizeSessionResponse = await fetch(this.options.authorizeSessionEndpoint, {
+                  method: 'POST',
+                  headers: {
+                      'Content-Type': 'application/json',
+                  },
+                  body: JSON.stringify(authorizeSessionRequestBody),
+              });
+              if (!authorizeSessionResponse.ok) {
+                  throw new Error(`Failed to authorize conversation: ${authorizeSessionResponse.statusText}`);
+              }
+              const authorizeSessionResponseBody = await authorizeSessionResponse.json();
+              this.conversationId = authorizeSessionResponseBody.conversation_id; // Save the conversation_id for use in future reconnects
+              this.options.conversationId = this.conversationId;
+              await this.wavRecorder.requestPermission();
+              this._setupDeviceChangeListener();
+              // Connect WebSocket
+              this.ws = new WebSocket(`${this._websocketUrl}?${new URLSearchParams({
+                client_session_key: authorizeSessionResponseBody.client_session_key,
+            })}`);
+              const config = authorizeSessionResponseBody.config;
+              console.log('AgentConfig', config);
+              // Store VAD configuration
+              this.vadConfig = config.vad || null;
+              if (config.transcription.trigger === 'push_to_talk') {
+                  this.pushToTalkEnabled = true;
+              }
+              else if (config.transcription.trigger === 'automatic') {
+                  this.pushToTalkEnabled = false;
+                  this.canInterrupt = config.transcription.can_interrupt;
+              }
+              else {
+                  throw new Error(`Unknown trigger: ${config.transcription.trigger}`);
+              }
+              // Bind the websocket message callbacks
+              this.ws.onmessage = this._handleWebSocketMessage;
+              this.ws.onopen = () => {
+                  console.log('WebSocket connection established');
+                  this._setStatus('connected');
+                  this.options.onConnect({ conversationId: this.conversationId });
+                  // Attempt to send ready message if recorder already started
+                  this._sendReadyIfNeeded();
+              };
+              this.ws.onclose = () => {
+                  console.log('WebSocket connection closed');
+                  this.ws = null;
+                  this._performDisconnectCleanup().catch((error) => {
+                      console.error('Error during disconnect cleanup:', error);
+                      this.options.onError(error instanceof Error ? error : new Error(String(error)));
+                  });
+              };
+              this.ws.onerror = (error) => {
+                  console.error('WebSocket error:', error);
+                  this._setStatus('error');
+                  this.options.onError(new Error('WebSocket connection error'));
+              };
+              // Initialize audio player
+              await this.wavPlayer.connect();
+              // Set up audio player amplitude monitoring
+              this._setupAmplitudeMonitoring(this.wavPlayer, this.options.onAgentAmplitudeChange, (amp) => (this.agentAudioAmplitude = amp));
+              // wavRecorder will be started from the onDeviceSwitched callback,
+              // which is called when the device is first initialized and also when the device is switched
+              // this is to ensure that the device is initialized before the recorder is started
+          }
+          catch (error) {
+              console.error('Error connecting to Layercode agent:', error);
+              this._setStatus('error');
+              this.options.onError(error instanceof Error ? error : new Error(String(error)));
+          }
+      }
+      _resetTurnTracking() {
+          this.currentTurnId = null;
+          console.debug('Reset turn tracking state');
+      }
+      async disconnect() {
+          if (this.status === 'disconnected') {
+              return;
+          }
+          if (this.ws) {
+              this.ws.onopen = null;
+              this.ws.onclose = null;
+              this.ws.onerror = null;
+              this.ws.onmessage = null;
+              this.ws.close();
+              this.ws = null;
+          }
+          await this._performDisconnectCleanup();
+      }
+      /**
+       * Gets the microphone MediaStream used by this client
+       * @returns {MediaStream|null} The microphone stream or null if not initialized
+       */
+      getStream() {
+          return this.wavRecorder.getStream();
+      }
+      /**
+       * List all available audio input devices
+       * @returns {Promise<Array<MediaDeviceInfo & {default: boolean}>>}
+       */
+      async listDevices() {
+          return this.wavRecorder.listDevices();
+      }
+      /**
+       * Switches the input device for the microphone and restarts recording
+       * @param {string} deviceId - The deviceId of the new microphone
+       */
+      async setInputDevice(deviceId) {
+          var _a, _b, _c;
+          try {
+              const normalizedDeviceId = !deviceId || deviceId === 'default' ? null : deviceId;
+              this.useSystemDefaultDevice = normalizedDeviceId === null;
+              this.deviceId = normalizedDeviceId;
+              // Restart recording with the new device
+              await this._restartAudioRecording();
+              // Reinitialize VAD with the new audio stream if VAD is enabled
+              const shouldUseVAD = !this.pushToTalkEnabled && ((_a = this.vadConfig) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
+              if (shouldUseVAD) {
+                  console.debug('Reinitializing VAD with new audio stream');
+                  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');
+              console.debug(`Successfully switched to input device: ${reportedDeviceId}`);
+          }
+          catch (error) {
+              console.error(`Failed to switch to input device ${deviceId}:`, error);
+              throw new Error(`Failed to switch to input device: ${error instanceof Error ? error.message : String(error)}`);
+          }
+      }
+      /**
+       * Restarts audio recording after a device switch to ensure audio is captured from the new device
+       */
+      async _restartAudioRecording() {
+          var _a, _b;
+          try {
+              console.debug('Restarting audio recording after device switch...');
+              try {
+                  await this.wavRecorder.end();
+              }
+              catch (_c) {
+                  // Ignore cleanup errors
+              }
+              // Start with new device
+              const targetDeviceId = this.useSystemDefaultDevice ? undefined : this.deviceId || undefined;
+              await this.wavRecorder.begin(targetDeviceId);
+              await this.wavRecorder.record(this._handleDataAvailable, 1638);
+              // Re-setup amplitude monitoring with the new stream
+              this._setupAmplitudeMonitoring(this.wavRecorder, this.options.onUserAmplitudeChange, (amp) => (this.userAudioAmplitude = amp));
+              const previousReportedDeviceId = this.lastReportedDeviceId;
+              const stream = this.wavRecorder.getStream();
+              const activeTrack = (stream === null || stream === void 0 ? void 0 : stream.getAudioTracks()[0]) || null;
+              const trackSettings = activeTrack && typeof activeTrack.getSettings === 'function' ? activeTrack.getSettings() : null;
+              const trackDeviceId = trackSettings && typeof trackSettings.deviceId === 'string' ? trackSettings.deviceId : null;
+              this.activeDeviceId = trackDeviceId !== null && trackDeviceId !== void 0 ? trackDeviceId : (this.useSystemDefaultDevice ? null : this.deviceId);
+              if (!this.recorderStarted) {
+                  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');
+              if (reportedDeviceId !== previousReportedDeviceId) {
+                  this.lastReportedDeviceId = reportedDeviceId;
+                  if (this.options.onDeviceSwitched) {
+                      this.options.onDeviceSwitched(reportedDeviceId);
+                  }
+              }
+              console.debug('Audio recording restart completed successfully');
+          }
+          catch (error) {
+              console.error('Error restarting audio recording after device switch:', error);
+              this.options.onError(error instanceof Error ? error : new Error(String(error)));
+          }
+      }
+      /**
+       * Reinitializes VAD with a new stream (used after device switching)
+       */
+      async _reinitializeVAD(stream) {
+          // Clean up existing VAD
+          if (this.vad) {
+              this.vad.pause();
+              this.vad.destroy();
+              this.vad = null;
+          }
+          // Reinitialize with new stream
+          if (stream) {
+              this._initializeVAD();
+          }
+      }
+      /**
+       * Sets up the device change event listener
+       */
+      _setupDeviceChangeListener() {
+          if (!this.deviceChangeListener) {
+              this.deviceChangeListener = async (devices) => {
+                  try {
+                      // Notify user that devices have changed
+                      this.options.onDevicesChanged(devices);
+                      const defaultDevice = devices.find((device) => device.default);
+                      const usingDefaultDevice = this.useSystemDefaultDevice;
+                      const previousDefaultDeviceKey = this.lastKnownSystemDefaultDeviceKey;
+                      const currentDefaultDeviceKey = this._getDeviceComparisonKey(defaultDevice);
+                      let shouldSwitch = !this.recorderStarted;
+                      if (!shouldSwitch) {
+                          if (usingDefaultDevice) {
+                              if (!defaultDevice) {
+                                  shouldSwitch = true;
+                              }
+                              else if (this.activeDeviceId && defaultDevice.deviceId !== 'default' && defaultDevice.deviceId !== this.activeDeviceId) {
+                                  shouldSwitch = true;
+                              }
+                              else if ((previousDefaultDeviceKey && previousDefaultDeviceKey !== currentDefaultDeviceKey) ||
+                                  (!previousDefaultDeviceKey && !currentDefaultDeviceKey && this.recorderStarted)) {
+                                  shouldSwitch = true;
+                              }
+                          }
+                          else {
+                              const matchesRequestedDevice = devices.some((device) => device.deviceId === this.deviceId || device.deviceId === this.activeDeviceId);
+                              shouldSwitch = !matchesRequestedDevice;
+                          }
+                      }
+                      this.lastKnownSystemDefaultDeviceKey = currentDefaultDeviceKey;
+                      if (shouldSwitch) {
+                          console.debug('Selecting fallback audio input device');
+                          const fallbackDevice = defaultDevice || devices[0];
+                          if (fallbackDevice) {
+                              const fallbackId = fallbackDevice.default ? 'default' : fallbackDevice.deviceId;
+                              await this.setInputDevice(fallbackId);
+                          }
+                          else {
+                              console.warn('No alternative audio device found');
+                          }
+                      }
+                  }
+                  catch (error) {
+                      this.options.onError(error instanceof Error ? error : new Error(String(error)));
+                  }
+              };
+          }
+          this.wavRecorder.listenForDeviceChange(this.deviceChangeListener);
+      }
+      _teardownDeviceListeners() {
+          this.wavRecorder.listenForDeviceChange(null);
+      }
+      async _performDisconnectCleanup() {
+          var _a, _b;
+          this.deviceId = null;
+          this.activeDeviceId = null;
+          this.useSystemDefaultDevice = false;
+          this.lastReportedDeviceId = null;
+          this.lastKnownSystemDefaultDeviceKey = null;
+          this.recorderStarted = false;
+          this.readySent = false;
+          this._stopAmplitudeMonitoring();
+          this._teardownDeviceListeners();
+          if (this.vad) {
+              this.vad.pause();
+              this.vad.destroy();
+              this.vad = null;
+          }
+          await this.wavRecorder.quit();
+          (_b = (_a = this.wavPlayer).stop) === null || _b === void 0 ? void 0 : _b.call(_a);
+          this.wavPlayer.disconnect();
+          this._resetTurnTracking();
+          this.options.conversationId = this.conversationId;
+          this.userAudioAmplitude = 0;
+          this.agentAudioAmplitude = 0;
+          this._setStatus('disconnected');
+          this.options.onDisconnect();
+      }
+      _getDeviceComparisonKey(device) {
+          if (!device || typeof device !== 'object') {
+              return null;
+          }
+          const deviceId = typeof device.deviceId === 'string' ? device.deviceId : '';
+          if (deviceId && deviceId !== 'default') {
+              return deviceId;
+          }
+          const groupId = typeof device.groupId === 'string' ? device.groupId : '';
+          if (groupId) {
+              return groupId;
+          }
+          const label = typeof device.label === 'string' ? device.label : '';
+          if (label) {
+              return label;
+          }
+          return null;
+      }
+      /**
+       * Mutes the microphone to stop sending audio to the server
+       * The connection and recording remain active for quick unmute
+       */
+      mute() {
+          if (!this.isMuted) {
+              this.isMuted = true;
+              console.log('Microphone muted');
+              this.options.onMuteStateChange(true);
+          }
+      }
+      /**
+       * Unmutes the microphone to resume sending audio to the server
+       */
+      unmute() {
+          if (this.isMuted) {
+              this.isMuted = false;
+              console.log('Microphone unmuted');
+              this.options.onMuteStateChange(false);
+          }
+      }
+  }
 
   return LayercodeClient;