@absolutejs/voice-deepgram 0.0.2

package/dist/index.js

@@ -0,0 +1,2422 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+// node_modules/cross-fetch/dist/node-ponyfill.js
+var require_node_ponyfill = __commonJS((exports, module) => {
+  var nodeFetch = __require("node-fetch");
+  var realFetch = nodeFetch.default || nodeFetch;
+  var fetch2 = function(url, options) {
+    if (/^\/\//.test(url)) {
+      url = "https:" + url;
+    }
+    return realFetch.call(this, url, options);
+  };
+  fetch2.ponyfill = true;
+  module.exports = exports = fetch2;
+  exports.fetch = fetch2;
+  exports.Headers = nodeFetch.Headers;
+  exports.Request = nodeFetch.Request;
+  exports.Response = nodeFetch.Response;
+  exports.default = fetch2;
+});
+
+// node_modules/deepmerge/dist/cjs.js
+var require_cjs = __commonJS((exports, module) => {
+  var isMergeableObject = function isMergeableObject2(value) {
+    return isNonNullObject(value) && !isSpecial(value);
+  };
+  function isNonNullObject(value) {
+    return !!value && typeof value === "object";
+  }
+  function isSpecial(value) {
+    var stringValue = Object.prototype.toString.call(value);
+    return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+  }
+  var canUseSymbol = typeof Symbol === "function" && Symbol.for;
+  var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
+  function isReactElement(value) {
+    return value.$$typeof === REACT_ELEMENT_TYPE;
+  }
+  function emptyTarget(val) {
+    return Array.isArray(val) ? [] : {};
+  }
+  function cloneUnlessOtherwiseSpecified(value, options) {
+    return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
+  }
+  function defaultArrayMerge(target, source, options) {
+    return target.concat(source).map(function(element) {
+      return cloneUnlessOtherwiseSpecified(element, options);
+    });
+  }
+  function getMergeFunction(key, options) {
+    if (!options.customMerge) {
+      return deepmerge;
+    }
+    var customMerge = options.customMerge(key);
+    return typeof customMerge === "function" ? customMerge : deepmerge;
+  }
+  function getEnumerableOwnPropertySymbols(target) {
+    return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+      return Object.propertyIsEnumerable.call(target, symbol);
+    }) : [];
+  }
+  function getKeys(target) {
+    return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+  }
+  function propertyIsOnObject(object, property) {
+    try {
+      return property in object;
+    } catch (_) {
+      return false;
+    }
+  }
+  function propertyIsUnsafe(target, key) {
+    return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+  }
+  function mergeObject(target, source, options) {
+    var destination = {};
+    if (options.isMergeableObject(target)) {
+      getKeys(target).forEach(function(key) {
+        destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+      });
+    }
+    getKeys(source).forEach(function(key) {
+      if (propertyIsUnsafe(target, key)) {
+        return;
+      }
+      if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+        destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+      } else {
+        destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+      }
+    });
+    return destination;
+  }
+  function deepmerge(target, source, options) {
+    options = options || {};
+    options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+    options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+    options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+    var sourceIsArray = Array.isArray(source);
+    var targetIsArray = Array.isArray(target);
+    var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+    if (!sourceAndTargetTypesMatch) {
+      return cloneUnlessOtherwiseSpecified(source, options);
+    } else if (sourceIsArray) {
+      return options.arrayMerge(target, source, options);
+    } else {
+      return mergeObject(target, source, options);
+    }
+  }
+  deepmerge.all = function deepmergeAll(array, options) {
+    if (!Array.isArray(array)) {
+      throw new Error("first argument should be an array");
+    }
+    return array.reduce(function(prev, next) {
+      return deepmerge(prev, next, options);
+    }, {});
+  };
+  var deepmerge_1 = deepmerge;
+  module.exports = deepmerge_1;
+});
+
+// node_modules/@deepgram/sdk/dist/module/lib/errors.js
+class DeepgramError extends Error {
+  constructor(message) {
+    super(message);
+    this.__dgError = true;
+    this.name = "DeepgramError";
+  }
+}
+function isDeepgramError(error) {
+  return typeof error === "object" && error !== null && "__dgError" in error;
+}
+
+class DeepgramApiError extends DeepgramError {
+  constructor(message, status) {
+    super(message);
+    this.name = "DeepgramApiError";
+    this.status = status;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status
+    };
+  }
+}
+
+class DeepgramUnknownError extends DeepgramError {
+  constructor(message, originalError) {
+    super(message);
+    this.name = "DeepgramUnknownError";
+    this.originalError = originalError;
+  }
+}
+
+class DeepgramVersionError extends DeepgramError {
+  constructor() {
+    super(`You are attempting to use an old format for a newer SDK version. Read more here: https://dpgr.am/js-v3`);
+    this.name = "DeepgramVersionError";
+  }
+}
+
+class DeepgramWebSocketError extends DeepgramError {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "DeepgramWebSocketError";
+    this.originalEvent = options.originalEvent;
+    this.statusCode = options.statusCode;
+    this.requestId = options.requestId;
+    this.responseHeaders = options.responseHeaders;
+    this.url = options.url;
+    this.readyState = options.readyState;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      requestId: this.requestId,
+      responseHeaders: this.responseHeaders,
+      url: this.url,
+      readyState: this.readyState,
+      originalEvent: this.originalEvent ? {
+        type: this.originalEvent.type,
+        timeStamp: this.originalEvent.timeStamp
+      } : undefined
+    };
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/AbstractClient.js
+import { EventEmitter } from "events";
+
+// node_modules/@deepgram/sdk/dist/module/lib/helpers.js
+var import_cross_fetch = __toESM(require_node_ponyfill(), 1);
+var import_deepmerge = __toESM(require_cjs(), 1);
+
+// node_modules/@deepgram/sdk/dist/module/lib/runtime.js
+var NODE_VERSION = typeof process !== "undefined" && process.versions && process.versions.node ? process.versions.node : "unknown";
+var BUN_VERSION = typeof process !== "undefined" && process.versions && process.versions.bun ? process.versions.bun : "unknown";
+var BROWSER_AGENT = typeof window !== "undefined" && window.navigator && window.navigator.userAgent ? window.navigator.userAgent : "unknown";
+var isBrowser = () => BROWSER_AGENT !== "unknown";
+var isNode = () => NODE_VERSION !== "unknown";
+var isBun = () => BUN_VERSION !== "unknown";
+
+// node_modules/@deepgram/sdk/dist/module/lib/helpers.js
+function applyDefaults(options = {}, subordinate = {}) {
+  return import_deepmerge.default(subordinate, options);
+}
+function appendSearchParams(searchParams, options) {
+  Object.keys(options).forEach((i) => {
+    if (Array.isArray(options[i])) {
+      const arrayParams = options[i];
+      arrayParams.forEach((param) => {
+        searchParams.append(i, String(param));
+      });
+    } else {
+      searchParams.append(i, String(options[i]));
+    }
+  });
+}
+var resolveHeadersConstructor = () => {
+  if (typeof Headers === "undefined") {
+    return import_cross_fetch.Headers;
+  }
+  return Headers;
+};
+var isUrlSource = (providedSource) => {
+  if (providedSource && providedSource.url)
+    return true;
+  return false;
+};
+var isTextSource = (providedSource) => {
+  if (providedSource && providedSource.text)
+    return true;
+  return false;
+};
+var isFileSource = (providedSource) => {
+  if (isReadStreamSource(providedSource) || isBufferSource(providedSource))
+    return true;
+  return false;
+};
+var isBufferSource = (providedSource) => {
+  return providedSource != null && Buffer.isBuffer(providedSource);
+};
+var isReadStreamSource = (providedSource) => {
+  if (providedSource == null)
+    return false;
+  if (isBrowser())
+    return false;
+  return typeof providedSource === "object" && typeof providedSource.pipe === "function" && typeof providedSource.read === "function" && typeof providedSource._readableState === "object";
+};
+var convertProtocolToWs = (url) => {
+  const convert = (string) => string.toLowerCase().replace(/^http/, "ws");
+  return convert(url);
+};
+var convertLegacyOptions = (optionsArg) => {
+  var _a, _b, _c, _d, _e, _f;
+  const newOptions = {};
+  if (optionsArg._experimentalCustomFetch) {
+    newOptions.global = {
+      fetch: {
+        client: optionsArg._experimentalCustomFetch
+      }
+    };
+  }
+  optionsArg = import_deepmerge.default(optionsArg, newOptions);
+  if ((_a = optionsArg.restProxy) === null || _a === undefined ? undefined : _a.url) {
+    newOptions.global = {
+      fetch: {
+        options: {
+          proxy: {
+            url: (_b = optionsArg.restProxy) === null || _b === undefined ? undefined : _b.url
+          }
+        }
+      }
+    };
+  }
+  optionsArg = import_deepmerge.default(optionsArg, newOptions);
+  if ((_c = optionsArg.global) === null || _c === undefined ? undefined : _c.url) {
+    newOptions.global = {
+      fetch: {
+        options: {
+          url: optionsArg.global.url
+        }
+      },
+      websocket: {
+        options: {
+          url: optionsArg.global.url
+        }
+      }
+    };
+  }
+  optionsArg = import_deepmerge.default(optionsArg, newOptions);
+  if ((_d = optionsArg.global) === null || _d === undefined ? undefined : _d.headers) {
+    newOptions.global = {
+      fetch: {
+        options: {
+          headers: (_e = optionsArg.global) === null || _e === undefined ? undefined : _e.headers
+        }
+      },
+      websocket: {
+        options: {
+          _nodeOnlyHeaders: (_f = optionsArg.global) === null || _f === undefined ? undefined : _f.headers
+        }
+      }
+    };
+  }
+  optionsArg = import_deepmerge.default(optionsArg, newOptions);
+  return optionsArg;
+};
+
+// node_modules/@deepgram/sdk/dist/module/lib/version.js
+var version = "4.11.3";
+
+// node_modules/@deepgram/sdk/dist/module/lib/constants.js
+var getAgent = () => {
+  if (isNode()) {
+    return `node/${NODE_VERSION}`;
+  } else if (isBun()) {
+    return `bun/${BUN_VERSION}`;
+  } else if (isBrowser()) {
+    return `javascript ${BROWSER_AGENT}`;
+  } else {
+    return `unknown`;
+  }
+};
+var DEFAULT_HEADERS = {
+  "Content-Type": `application/json`,
+  "X-Client-Info": `@deepgram/sdk; ${isBrowser() ? "browser" : "server"}; v${version}`,
+  "User-Agent": `@deepgram/sdk/${version} ${getAgent()}`
+};
+var DEFAULT_URL = "https://api.deepgram.com";
+var DEFAULT_AGENT_URL = "wss://agent.deepgram.com";
+var DEFAULT_GLOBAL_OPTIONS = {
+  fetch: { options: { url: DEFAULT_URL, headers: DEFAULT_HEADERS } },
+  websocket: {
+    options: { url: convertProtocolToWs(DEFAULT_URL), _nodeOnlyHeaders: DEFAULT_HEADERS }
+  }
+};
+var DEFAULT_AGENT_OPTIONS = {
+  fetch: { options: { url: DEFAULT_URL, headers: DEFAULT_HEADERS } },
+  websocket: {
+    options: { url: DEFAULT_AGENT_URL, _nodeOnlyHeaders: DEFAULT_HEADERS }
+  }
+};
+var DEFAULT_OPTIONS = {
+  global: DEFAULT_GLOBAL_OPTIONS,
+  agent: DEFAULT_AGENT_OPTIONS
+};
+var SOCKET_STATES;
+(function(SOCKET_STATES2) {
+  SOCKET_STATES2[SOCKET_STATES2["connecting"] = 0] = "connecting";
+  SOCKET_STATES2[SOCKET_STATES2["open"] = 1] = "open";
+  SOCKET_STATES2[SOCKET_STATES2["closing"] = 2] = "closing";
+  SOCKET_STATES2[SOCKET_STATES2["closed"] = 3] = "closed";
+})(SOCKET_STATES || (SOCKET_STATES = {}));
+var CONNECTION_STATE;
+(function(CONNECTION_STATE2) {
+  CONNECTION_STATE2["Connecting"] = "connecting";
+  CONNECTION_STATE2["Open"] = "open";
+  CONNECTION_STATE2["Closing"] = "closing";
+  CONNECTION_STATE2["Closed"] = "closed";
+})(CONNECTION_STATE || (CONNECTION_STATE = {}));
+
+// node_modules/@deepgram/sdk/dist/module/packages/AbstractClient.js
+var noop = () => {};
+
+class AbstractClient extends EventEmitter {
+  constructor(options) {
+    super();
+    this.factory = undefined;
+    this.key = undefined;
+    this.accessToken = undefined;
+    this.namespace = "global";
+    this.version = "v1";
+    this.baseUrl = DEFAULT_URL;
+    this.logger = noop;
+    if (typeof options.accessToken === "function") {
+      this.factory = options.accessToken;
+      this.accessToken = this.factory();
+    } else {
+      this.accessToken = options.accessToken;
+    }
+    if (typeof options.key === "function") {
+      this.factory = options.key;
+      this.key = this.factory();
+    } else {
+      this.key = options.key;
+    }
+    if (!this.key && !this.accessToken) {
+      this.accessToken = process.env.DEEPGRAM_ACCESS_TOKEN;
+      if (!this.accessToken) {
+        this.key = process.env.DEEPGRAM_API_KEY;
+      }
+    }
+    if (!this.key && !this.accessToken) {
+      throw new DeepgramError("A deepgram API key or access token is required.");
+    }
+    options = convertLegacyOptions(options);
+    this.options = applyDefaults(options, DEFAULT_OPTIONS);
+  }
+  v(version2 = "v1") {
+    this.version = version2;
+    return this;
+  }
+  get namespaceOptions() {
+    const defaults = applyDefaults(this.options[this.namespace], this.options.global);
+    return Object.assign(Object.assign({}, defaults), { key: this.key });
+  }
+  getRequestUrl(endpoint, fields = { version: this.version }, transcriptionOptions) {
+    fields.version = this.version;
+    endpoint = endpoint.replace(/:(\w+)/g, function(_, key) {
+      return fields[key];
+    });
+    const url = new URL(endpoint, this.baseUrl);
+    if (transcriptionOptions) {
+      appendSearchParams(url.searchParams, transcriptionOptions);
+    }
+    return url;
+  }
+  log(kind, msg, data) {
+    this.logger(kind, msg, data);
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/AbstractLiveClient.js
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var NATIVE_WEBSOCKET_AVAILABLE = typeof WebSocket !== "undefined";
+
+class AbstractLiveClient extends AbstractClient {
+  constructor(options) {
+    super(options);
+    this.conn = null;
+    this.sendBuffer = [];
+    this.reconnect = noop;
+    const { key, websocket: { options: websocketOptions, client } } = this.namespaceOptions;
+    if (this.proxy) {
+      this.baseUrl = websocketOptions.proxy.url;
+    } else {
+      this.baseUrl = websocketOptions.url;
+    }
+    if (client) {
+      this.transport = client;
+    } else {
+      this.transport = null;
+    }
+    if (websocketOptions._nodeOnlyHeaders) {
+      this.headers = websocketOptions._nodeOnlyHeaders;
+    } else {
+      this.headers = {};
+    }
+    if (!("Authorization" in this.headers)) {
+      if (this.accessToken) {
+        this.headers["Authorization"] = `Bearer ${this.accessToken}`;
+      } else {
+        this.headers["Authorization"] = `Token ${key}`;
+      }
+    }
+  }
+  connect(transcriptionOptions, endpoint) {
+    if (this.conn) {
+      return;
+    }
+    this.reconnect = (options = transcriptionOptions) => {
+      this.connect(options, endpoint);
+    };
+    const requestUrl = this.getRequestUrl(endpoint, {}, transcriptionOptions);
+    const accessToken = this.accessToken;
+    const apiKey = this.key;
+    if (!accessToken && !apiKey) {
+      throw new Error("No key or access token provided for WebSocket connection.");
+    }
+    if (this.transport) {
+      this.conn = new this.transport(requestUrl, undefined, {
+        headers: this.headers
+      });
+      this.setupConnection();
+      return;
+    }
+    if (isBun()) {
+      import("ws").then(({ default: WS }) => {
+        this.conn = new WS(requestUrl, {
+          headers: this.headers
+        });
+        console.log(`Using WS package`);
+        this.setupConnection();
+      });
+      return;
+    }
+    if (NATIVE_WEBSOCKET_AVAILABLE) {
+      this.conn = new WebSocket(requestUrl, accessToken ? ["bearer", accessToken] : ["token", apiKey]);
+      this.setupConnection();
+      return;
+    }
+    this.conn = new WSWebSocketDummy(requestUrl, undefined, {
+      close: () => {
+        this.conn = null;
+      }
+    });
+    import("ws").then(({ default: WS }) => {
+      this.conn = new WS(requestUrl, undefined, {
+        headers: this.headers
+      });
+      this.setupConnection();
+    });
+  }
+  disconnect(code, reason) {
+    if (this.conn) {
+      this.conn.onclose = function() {};
+      if (code) {
+        this.conn.close(code, reason !== null && reason !== undefined ? reason : "");
+      } else {
+        this.conn.close();
+      }
+      this.conn = null;
+    }
+  }
+  connectionState() {
+    switch (this.conn && this.conn.readyState) {
+      case SOCKET_STATES.connecting:
+        return CONNECTION_STATE.Connecting;
+      case SOCKET_STATES.open:
+        return CONNECTION_STATE.Open;
+      case SOCKET_STATES.closing:
+        return CONNECTION_STATE.Closing;
+      default:
+        return CONNECTION_STATE.Closed;
+    }
+  }
+  getReadyState() {
+    var _a, _b;
+    return (_b = (_a = this.conn) === null || _a === undefined ? undefined : _a.readyState) !== null && _b !== undefined ? _b : SOCKET_STATES.closed;
+  }
+  isConnected() {
+    return this.connectionState() === CONNECTION_STATE.Open;
+  }
+  send(data) {
+    const callback = () => __awaiter(this, undefined, undefined, function* () {
+      var _a;
+      if (data instanceof Blob) {
+        if (data.size === 0) {
+          this.log("warn", "skipping `send` for zero-byte blob", data);
+          return;
+        }
+        data = yield data.arrayBuffer();
+      }
+      if (typeof data !== "string") {
+        if (!(data === null || data === undefined ? undefined : data.byteLength)) {
+          this.log("warn", "skipping `send` for zero-byte payload", data);
+          return;
+        }
+      }
+      (_a = this.conn) === null || _a === undefined || _a.send(data);
+    });
+    if (this.isConnected()) {
+      callback();
+    } else {
+      this.sendBuffer.push(callback);
+    }
+  }
+  get proxy() {
+    var _a;
+    return this.key === "proxy" && !!((_a = this.namespaceOptions.websocket.options.proxy) === null || _a === undefined ? undefined : _a.url);
+  }
+  extractErrorInformation(event, conn) {
+    var _a;
+    const errorInfo = {};
+    if (conn) {
+      errorInfo.readyState = conn.readyState;
+      errorInfo.url = typeof conn.url === "string" ? conn.url : (_a = conn.url) === null || _a === undefined ? undefined : _a.toString();
+    }
+    if (conn && typeof conn === "object") {
+      const wsConn = conn;
+      if (wsConn._req && wsConn._req.res) {
+        errorInfo.statusCode = wsConn._req.res.statusCode;
+        if (wsConn._req.res.headers) {
+          errorInfo.responseHeaders = Object.assign({}, wsConn._req.res.headers);
+          const requestId = wsConn._req.res.headers["dg-request-id"] || wsConn._req.res.headers["x-dg-request-id"];
+          if (requestId) {
+            errorInfo.requestId = requestId;
+          }
+        }
+      }
+      if (event && "target" in event && event.target) {
+        const target = event.target;
+        if (target.url) {
+          errorInfo.url = target.url;
+        }
+        if (target.readyState !== undefined) {
+          errorInfo.readyState = target.readyState;
+        }
+      }
+    }
+    return errorInfo;
+  }
+  createEnhancedError(event, enhancedInfo) {
+    const enhancedError = new DeepgramWebSocketError(event.message || "WebSocket connection error", Object.assign({ originalEvent: event }, enhancedInfo));
+    return Object.assign(Object.assign({}, event), {
+      error: enhancedError,
+      statusCode: enhancedInfo.statusCode,
+      requestId: enhancedInfo.requestId,
+      responseHeaders: enhancedInfo.responseHeaders,
+      url: enhancedInfo.url,
+      readyState: enhancedInfo.readyState,
+      message: this.buildEnhancedErrorMessage(event, enhancedInfo)
+    });
+  }
+  buildEnhancedErrorMessage(event, enhancedInfo) {
+    let message = event.message || "WebSocket connection error";
+    const details = [];
+    if (enhancedInfo.statusCode) {
+      details.push(`Status: ${enhancedInfo.statusCode}`);
+    }
+    if (enhancedInfo.requestId) {
+      details.push(`Request ID: ${enhancedInfo.requestId}`);
+    }
+    if (enhancedInfo.readyState !== undefined) {
+      const stateNames = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+      const stateName = stateNames[enhancedInfo.readyState] || `Unknown(${enhancedInfo.readyState})`;
+      details.push(`Ready State: ${stateName}`);
+    }
+    if (enhancedInfo.url) {
+      details.push(`URL: ${enhancedInfo.url}`);
+    }
+    if (details.length > 0) {
+      message += ` (${details.join(", ")})`;
+    }
+    return message;
+  }
+  setupConnectionEvents(events) {
+    if (this.conn) {
+      this.conn.onopen = () => {
+        this.emit(events.Open, this);
+      };
+      this.conn.onclose = (event) => {
+        this.emit(events.Close, event);
+      };
+      this.conn.onerror = (event) => {
+        const enhancedInfo = this.extractErrorInformation(event, this.conn || undefined);
+        const enhancedError = this.createEnhancedError(event, enhancedInfo);
+        this.emit(events.Error, enhancedError);
+      };
+    }
+  }
+}
+
+class WSWebSocketDummy {
+  constructor(address, _protocols, options) {
+    this.binaryType = "arraybuffer";
+    this.onclose = () => {};
+    this.onerror = () => {};
+    this.onmessage = () => {};
+    this.onopen = () => {};
+    this.readyState = SOCKET_STATES.connecting;
+    this.send = () => {};
+    this.url = null;
+    this.url = address.toString();
+    this.close = options.close;
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/lib/fetch.js
+var import_cross_fetch2 = __toESM(require_node_ponyfill(), 1);
+var __awaiter2 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var resolveFetch = (customFetch) => {
+  let _fetch;
+  if (customFetch) {
+    _fetch = customFetch;
+  } else if (typeof fetch === "undefined") {
+    _fetch = import_cross_fetch2.default;
+  } else {
+    _fetch = fetch;
+  }
+  return (...args) => _fetch(...args);
+};
+var fetchWithAuth = ({ apiKey, customFetch, accessToken }) => {
+  const fetch2 = resolveFetch(customFetch);
+  const HeadersConstructor = resolveHeadersConstructor();
+  return (input, init) => __awaiter2(undefined, undefined, undefined, function* () {
+    const headers = new HeadersConstructor(init === null || init === undefined ? undefined : init.headers);
+    if (!headers.has("Authorization")) {
+      headers.set("Authorization", accessToken ? `Bearer ${accessToken}` : `Token ${apiKey}`);
+    }
+    return fetch2(input, Object.assign(Object.assign({}, init), { headers }));
+  });
+};
+var resolveResponse = () => __awaiter2(undefined, undefined, undefined, function* () {
+  if (typeof Response === "undefined") {
+    return (yield Promise.resolve().then(() => __toESM(require_node_ponyfill(), 1))).Response;
+  }
+  return Response;
+});
+
+// node_modules/@deepgram/sdk/dist/module/packages/AbstractRestClient.js
+var import_deepmerge2 = __toESM(require_cjs(), 1);
+var __awaiter3 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class AbstractRestClient extends AbstractClient {
+  constructor(options) {
+    super(options);
+    if (isBrowser() && !this.proxy) {
+      throw new DeepgramError("Due to CORS we are unable to support REST-based API calls to our API from the browser. Please consider using a proxy: https://dpgr.am/js-proxy for more information.");
+    }
+    const { accessToken, key: apiKey, fetch: customFetch } = this;
+    this.fetch = fetchWithAuth({ accessToken, apiKey, customFetch });
+    if (this.proxy) {
+      this.baseUrl = this.namespaceOptions.fetch.options.proxy.url;
+    } else {
+      this.baseUrl = this.namespaceOptions.fetch.options.url;
+    }
+  }
+  _getErrorMessage(err) {
+    return err.msg || err.message || err.error_description || err.error || JSON.stringify(err);
+  }
+  _handleError(error, reject) {
+    return __awaiter3(this, undefined, undefined, function* () {
+      const Res = yield resolveResponse();
+      if (error instanceof Res) {
+        error.json().then((err) => {
+          reject(new DeepgramApiError(this._getErrorMessage(err), error.status || 500));
+        }).catch((err) => {
+          reject(new DeepgramUnknownError(this._getErrorMessage(err), err));
+        });
+      } else {
+        reject(new DeepgramUnknownError(this._getErrorMessage(error), error));
+      }
+    });
+  }
+  _getRequestOptions(method, bodyOrOptions, options) {
+    let reqOptions = { method };
+    if (method === "GET" || method === "DELETE") {
+      reqOptions = Object.assign(Object.assign({}, reqOptions), bodyOrOptions);
+    } else {
+      reqOptions = Object.assign(Object.assign({ duplex: "half", body: bodyOrOptions }, reqOptions), options);
+    }
+    return import_deepmerge2.default(this.namespaceOptions.fetch.options, reqOptions, { clone: false });
+  }
+  _handleRequest(method, url, bodyOrOptions, options) {
+    return __awaiter3(this, undefined, undefined, function* () {
+      return new Promise((resolve, reject) => {
+        const fetcher = this.fetch;
+        fetcher(url, this._getRequestOptions(method, bodyOrOptions, options)).then((result) => {
+          if (!result.ok)
+            throw result;
+          resolve(result);
+        }).catch((error) => this._handleError(error, reject));
+      });
+    });
+  }
+  get(url, options) {
+    return __awaiter3(this, undefined, undefined, function* () {
+      return this._handleRequest("GET", url, options);
+    });
+  }
+  post(url, body, options) {
+    return __awaiter3(this, undefined, undefined, function* () {
+      return this._handleRequest("POST", url, body, options);
+    });
+  }
+  put(url, body, options) {
+    return __awaiter3(this, undefined, undefined, function* () {
+      return this._handleRequest("PUT", url, body, options);
+    });
+  }
+  patch(url, body, options) {
+    return __awaiter3(this, undefined, undefined, function* () {
+      return this._handleRequest("PATCH", url, body, options);
+    });
+  }
+  delete(url, options) {
+    return __awaiter3(this, undefined, undefined, function* () {
+      return this._handleRequest("DELETE", url, options);
+    });
+  }
+  get proxy() {
+    var _a;
+    return this.key === "proxy" && !!((_a = this.namespaceOptions.fetch.options.proxy) === null || _a === undefined ? undefined : _a.url);
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/lib/enums/AgentEvents.js
+var AgentEvents;
+(function(AgentEvents2) {
+  AgentEvents2["Open"] = "Open";
+  AgentEvents2["Close"] = "Close";
+  AgentEvents2["Error"] = "Error";
+  AgentEvents2["Audio"] = "Audio";
+  AgentEvents2["Welcome"] = "Welcome";
+  AgentEvents2["SettingsApplied"] = "SettingsApplied";
+  AgentEvents2["ConversationText"] = "ConversationText";
+  AgentEvents2["UserStartedSpeaking"] = "UserStartedSpeaking";
+  AgentEvents2["AgentThinking"] = "AgentThinking";
+  AgentEvents2["FunctionCallRequest"] = "FunctionCallRequest";
+  AgentEvents2["AgentStartedSpeaking"] = "AgentStartedSpeaking";
+  AgentEvents2["AgentAudioDone"] = "AgentAudioDone";
+  AgentEvents2["InjectionRefused"] = "InjectionRefused";
+  AgentEvents2["PromptUpdated"] = "PromptUpdated";
+  AgentEvents2["SpeakUpdated"] = "SpeakUpdated";
+  AgentEvents2["Unhandled"] = "Unhandled";
+})(AgentEvents || (AgentEvents = {}));
+
+// node_modules/@deepgram/sdk/dist/module/packages/AgentLiveClient.js
+class AgentLiveClient extends AbstractLiveClient {
+  constructor(options, endpoint = "/:version/agent/converse") {
+    var _a, _b, _c, _d;
+    super(options);
+    this.namespace = "agent";
+    this.baseUrl = (_d = (_c = (_b = (_a = options.agent) === null || _a === undefined ? undefined : _a.websocket) === null || _b === undefined ? undefined : _b.options) === null || _c === undefined ? undefined : _c.url) !== null && _d !== undefined ? _d : DEFAULT_AGENT_URL;
+    this.connect({}, endpoint);
+  }
+  setupConnection() {
+    this.setupConnectionEvents({
+      Open: AgentEvents.Open,
+      Close: AgentEvents.Close,
+      Error: AgentEvents.Error
+    });
+    if (this.conn) {
+      this.conn.onmessage = (event) => {
+        this.handleMessage(event);
+      };
+    }
+  }
+  handleMessage(event) {
+    var _a, _b, _c, _d, _e, _f;
+    if (typeof event.data === "string") {
+      try {
+        const data = JSON.parse(event.data);
+        this.handleTextMessage(data);
+      } catch (error) {
+        this.emit(AgentEvents.Error, {
+          event,
+          data: ((_a = event.data) === null || _a === undefined ? undefined : _a.toString().substring(0, 200)) + (((_b = event.data) === null || _b === undefined ? undefined : _b.toString().length) > 200 ? "..." : ""),
+          message: "Unable to parse `data` as JSON.",
+          error,
+          url: (_c = this.conn) === null || _c === undefined ? undefined : _c.url,
+          readyState: (_d = this.conn) === null || _d === undefined ? undefined : _d.readyState
+        });
+      }
+    } else if (event.data instanceof Blob) {
+      event.data.arrayBuffer().then((buffer) => {
+        this.handleBinaryMessage(Buffer.from(buffer));
+      });
+    } else if (event.data instanceof ArrayBuffer) {
+      this.handleBinaryMessage(Buffer.from(event.data));
+    } else if (Buffer.isBuffer(event.data)) {
+      this.handleBinaryMessage(event.data);
+    } else {
+      console.log("Received unknown data type", event.data);
+      this.emit(AgentEvents.Error, {
+        event,
+        message: "Received unknown data type.",
+        url: (_e = this.conn) === null || _e === undefined ? undefined : _e.url,
+        readyState: (_f = this.conn) === null || _f === undefined ? undefined : _f.readyState,
+        dataType: typeof event.data
+      });
+    }
+  }
+  handleBinaryMessage(data) {
+    this.emit(AgentEvents.Audio, data);
+  }
+  handleTextMessage(data) {
+    if (data.type in AgentEvents) {
+      this.emit(data.type, data);
+    } else {
+      this.emit(AgentEvents.Unhandled, data);
+    }
+  }
+  configure(options) {
+    const string = JSON.stringify(Object.assign({ type: "Settings" }, options));
+    this.send(string);
+  }
+  updatePrompt(prompt) {
+    this.send(JSON.stringify({ type: "UpdatePrompt", prompt }));
+  }
+  updateSpeak(speakConfig) {
+    this.send(JSON.stringify({ type: "UpdateSpeak", speak: speakConfig }));
+  }
+  injectAgentMessage(content) {
+    this.send(JSON.stringify({ type: "InjectAgentMessage", content }));
+  }
+  injectUserMessage(content) {
+    this.send(JSON.stringify({ type: "InjectUserMessage", content }));
+  }
+  functionCallResponse(response) {
+    this.send(JSON.stringify(Object.assign({ type: "FunctionCallResponse" }, response)));
+  }
+  keepAlive() {
+    this.send(JSON.stringify({ type: "KeepAlive" }));
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/AuthRestClient.js
+var __awaiter4 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class AuthRestClient extends AbstractRestClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "auth";
+  }
+  grantToken(options = {}, endpoint = ":version/auth/grant") {
+    return __awaiter4(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint);
+        const body = JSON.stringify(options);
+        const result = yield this.post(requestUrl, body, {
+          headers: { "Content-Type": "application/json" }
+        }).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/lib/enums/LiveTranscriptionEvents.js
+var LiveTranscriptionEvents;
+(function(LiveTranscriptionEvents2) {
+  LiveTranscriptionEvents2["Open"] = "open";
+  LiveTranscriptionEvents2["Close"] = "close";
+  LiveTranscriptionEvents2["Error"] = "error";
+  LiveTranscriptionEvents2["Transcript"] = "Results";
+  LiveTranscriptionEvents2["Metadata"] = "Metadata";
+  LiveTranscriptionEvents2["UtteranceEnd"] = "UtteranceEnd";
+  LiveTranscriptionEvents2["SpeechStarted"] = "SpeechStarted";
+  LiveTranscriptionEvents2["Unhandled"] = "Unhandled";
+})(LiveTranscriptionEvents || (LiveTranscriptionEvents = {}));
+
+// node_modules/@deepgram/sdk/dist/module/lib/enums/LiveTTSEvents.js
+var LiveTTSEvents;
+(function(LiveTTSEvents2) {
+  LiveTTSEvents2["Open"] = "Open";
+  LiveTTSEvents2["Close"] = "Close";
+  LiveTTSEvents2["Error"] = "Error";
+  LiveTTSEvents2["Metadata"] = "Metadata";
+  LiveTTSEvents2["Flushed"] = "Flushed";
+  LiveTTSEvents2["Warning"] = "Warning";
+  LiveTTSEvents2["Audio"] = "Audio";
+  LiveTTSEvents2["Unhandled"] = "Unhandled";
+})(LiveTTSEvents || (LiveTTSEvents = {}));
+
+// node_modules/@deepgram/sdk/dist/module/packages/ListenLiveClient.js
+class ListenLiveClient extends AbstractLiveClient {
+  constructor(options, transcriptionOptions = {}, endpoint = ":version/listen") {
+    super(options);
+    this.namespace = "listen";
+    this.connect(transcriptionOptions, endpoint);
+  }
+  setupConnection() {
+    this.setupConnectionEvents({
+      Open: LiveTranscriptionEvents.Open,
+      Close: LiveTranscriptionEvents.Close,
+      Error: LiveTranscriptionEvents.Error
+    });
+    if (this.conn) {
+      this.conn.onmessage = (event) => {
+        var _a, _b, _c, _d;
+        try {
+          const data = JSON.parse(event.data.toString());
+          if (data.type === LiveTranscriptionEvents.Metadata) {
+            this.emit(LiveTranscriptionEvents.Metadata, data);
+          } else if (data.type === LiveTranscriptionEvents.Transcript) {
+            this.emit(LiveTranscriptionEvents.Transcript, data);
+          } else if (data.type === LiveTranscriptionEvents.UtteranceEnd) {
+            this.emit(LiveTranscriptionEvents.UtteranceEnd, data);
+          } else if (data.type === LiveTranscriptionEvents.SpeechStarted) {
+            this.emit(LiveTranscriptionEvents.SpeechStarted, data);
+          } else {
+            this.emit(LiveTranscriptionEvents.Unhandled, data);
+          }
+        } catch (error) {
+          this.emit(LiveTranscriptionEvents.Error, {
+            event,
+            message: "Unable to parse `data` as JSON.",
+            error,
+            url: (_a = this.conn) === null || _a === undefined ? undefined : _a.url,
+            readyState: (_b = this.conn) === null || _b === undefined ? undefined : _b.readyState,
+            data: ((_c = event.data) === null || _c === undefined ? undefined : _c.toString().substring(0, 200)) + (((_d = event.data) === null || _d === undefined ? undefined : _d.toString().length) > 200 ? "..." : "")
+          });
+        }
+      };
+    }
+  }
+  configure(config) {
+    this.send(JSON.stringify({
+      type: "Configure",
+      processors: config
+    }));
+  }
+  keepAlive() {
+    this.send(JSON.stringify({
+      type: "KeepAlive"
+    }));
+  }
+  finalize() {
+    this.send(JSON.stringify({
+      type: "Finalize"
+    }));
+  }
+  finish() {
+    this.requestClose();
+  }
+  requestClose() {
+    this.send(JSON.stringify({
+      type: "CloseStream"
+    }));
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/ListenRestClient.js
+var __awaiter5 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class ListenRestClient extends AbstractRestClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "listen";
+  }
+  transcribeUrl(source, options, endpoint = ":version/listen") {
+    var _a, _b;
+    return __awaiter5(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isUrlSource(source)) {
+          body = JSON.stringify(source);
+        } else {
+          throw new DeepgramError("Unknown transcription source type");
+        }
+        if (options !== undefined && "callback" in options) {
+          throw new DeepgramError("Callback cannot be provided as an option to a synchronous transcription. Use `transcribeUrlCallback` or `transcribeFileCallback` instead.");
+        }
+        if (((_a = options === null || options === undefined ? undefined : options.keyterm) === null || _a === undefined ? undefined : _a.length) && !((_b = options.model) === null || _b === undefined ? undefined : _b.startsWith("nova-3"))) {
+          throw new DeepgramError("Keyterms are only supported with the Nova 3 models.");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign({}, options));
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  transcribeFile(source, options, endpoint = ":version/listen") {
+    return __awaiter5(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isFileSource(source)) {
+          body = source;
+        } else {
+          throw new DeepgramError("Unknown transcription source type");
+        }
+        if (options !== undefined && "callback" in options) {
+          throw new DeepgramError("Callback cannot be provided as an option to a synchronous transcription. Use `transcribeUrlCallback` or `transcribeFileCallback` instead.");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign({}, options));
+        const result = yield this.post(requestUrl, body, {
+          headers: { "Content-Type": "deepgram/audio+video" }
+        }).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  transcribeUrlCallback(source, callback, options, endpoint = ":version/listen") {
+    return __awaiter5(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isUrlSource(source)) {
+          body = JSON.stringify(source);
+        } else {
+          throw new DeepgramError("Unknown transcription source type");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign(Object.assign({}, options), { callback: callback.toString() }));
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  transcribeFileCallback(source, callback, options, endpoint = ":version/listen") {
+    return __awaiter5(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isFileSource(source)) {
+          body = source;
+        } else {
+          throw new DeepgramError("Unknown transcription source type");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign(Object.assign({}, options), { callback: callback.toString() }));
+        const result = yield this.post(requestUrl, body, {
+          headers: { "Content-Type": "deepgram/audio+video" }
+        }).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/ListenClient.js
+class ListenClient extends AbstractClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "listen";
+  }
+  get prerecorded() {
+    return new ListenRestClient(this.options);
+  }
+  live(transcriptionOptions = {}, endpoint = ":version/listen") {
+    return new ListenLiveClient(this.options, transcriptionOptions, endpoint);
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/ManageRestClient.js
+var __awaiter6 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class ManageRestClient extends AbstractRestClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "manage";
+  }
+  getTokenDetails(endpoint = ":version/auth/token") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint);
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjects(endpoint = ":version/projects") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint);
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProject(projectId, endpoint = ":version/projects/:projectId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  updateProject(projectId, options, endpoint = ":version/projects/:projectId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId }, options);
+        const body = JSON.stringify(options);
+        const result = yield this.patch(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  deleteProject(projectId, endpoint = ":version/projects/:projectId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        yield this.delete(requestUrl);
+        return { error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectKeys(projectId, endpoint = ":version/projects/:projectId/keys") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectKey(projectId, keyId, endpoint = ":version/projects/:projectId/keys/:keyId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, keyId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  createProjectKey(projectId, options, endpoint = ":version/projects/:projectId/keys") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId }, options);
+        const body = JSON.stringify(options);
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  deleteProjectKey(projectId, keyId, endpoint = ":version/projects/:projectId/keys/:keyId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, keyId });
+        yield this.delete(requestUrl);
+        return { error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectMembers(projectId, endpoint = ":version/projects/:projectId/members") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  removeProjectMember(projectId, memberId, endpoint = ":version/projects/:projectId/members/:memberId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, memberId });
+        yield this.delete(requestUrl);
+        return { error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectMemberScopes(projectId, memberId, endpoint = ":version/projects/:projectId/members/:memberId/scopes") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, memberId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  updateProjectMemberScope(projectId, memberId, options, endpoint = ":version/projects/:projectId/members/:memberId/scopes") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, memberId }, options);
+        const body = JSON.stringify(options);
+        const result = yield this.put(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectInvites(projectId, endpoint = ":version/projects/:projectId/invites") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  sendProjectInvite(projectId, options, endpoint = ":version/projects/:projectId/invites") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId }, options);
+        const body = JSON.stringify(options);
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  deleteProjectInvite(projectId, email, endpoint = ":version/projects/:projectId/invites/:email") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, email });
+        yield this.delete(requestUrl);
+        return { error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { error };
+        }
+        throw error;
+      }
+    });
+  }
+  leaveProject(projectId, endpoint = ":version/projects/:projectId/leave") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const result = yield this.delete(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectUsageRequests(projectId, options, endpoint = ":version/projects/:projectId/requests") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId }, options);
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectUsageRequest(projectId, requestId, endpoint = ":version/projects/:projectId/requests/:requestId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, requestId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectUsageSummary(projectId, options, endpoint = ":version/projects/:projectId/usage") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId }, options);
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectUsageFields(projectId, options, endpoint = ":version/projects/:projectId/usage/fields") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId }, options);
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectBalances(projectId, endpoint = ":version/projects/:projectId/balances") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getProjectBalance(projectId, balanceId, endpoint = ":version/projects/:projectId/balances/:balanceId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, balanceId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getAllModels(projectId, options = {}, endpoint = ":version/projects/:projectId/models") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId }, options);
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getModel(projectId, modelId, endpoint = ":version/projects/:projectId/models/:modelId") {
+    return __awaiter6(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, modelId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/ModelsRestClient.js
+var __awaiter7 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class ModelsRestClient extends AbstractRestClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "models";
+  }
+  getAll(endpoint = ":version/models", options = {}) {
+    return __awaiter7(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, {}, options);
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getModel(modelId, endpoint = ":version/models/:modelId") {
+    return __awaiter7(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { modelId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/ReadRestClient.js
+var __awaiter8 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class ReadRestClient extends AbstractRestClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "read";
+  }
+  analyzeUrl(source, options, endpoint = ":version/read") {
+    return __awaiter8(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isUrlSource(source)) {
+          body = JSON.stringify(source);
+        } else {
+          throw new DeepgramError("Unknown source type");
+        }
+        if (options !== undefined && "callback" in options) {
+          throw new DeepgramError("Callback cannot be provided as an option to a synchronous transcription. Use `analyzeUrlCallback` or `analyzeTextCallback` instead.");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign({}, options));
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  analyzeText(source, options, endpoint = ":version/read") {
+    return __awaiter8(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isTextSource(source)) {
+          body = JSON.stringify(source);
+        } else {
+          throw new DeepgramError("Unknown source type");
+        }
+        if (options !== undefined && "callback" in options) {
+          throw new DeepgramError("Callback cannot be provided as an option to a synchronous requests. Use `analyzeUrlCallback` or `analyzeTextCallback` instead.");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign({}, options));
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  analyzeUrlCallback(source, callback, options, endpoint = ":version/read") {
+    return __awaiter8(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isUrlSource(source)) {
+          body = JSON.stringify(source);
+        } else {
+          throw new DeepgramError("Unknown source type");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign(Object.assign({}, options), { callback: callback.toString() }));
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  analyzeTextCallback(source, callback, options, endpoint = ":version/read") {
+    return __awaiter8(this, undefined, undefined, function* () {
+      try {
+        let body;
+        if (isTextSource(source)) {
+          body = JSON.stringify(source);
+        } else {
+          throw new DeepgramError("Unknown source type");
+        }
+        const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign(Object.assign({}, options), { callback: callback.toString() }));
+        const result = yield this.post(requestUrl, body, {
+          headers: { "Content-Type": "deepgram/audio+video" }
+        }).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/SelfHostedRestClient.js
+var __awaiter9 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class SelfHostedRestClient extends AbstractRestClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "selfhosted";
+  }
+  listCredentials(projectId, endpoint = ":version/projects/:projectId/onprem/distribution/credentials") {
+    return __awaiter9(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  getCredentials(projectId, credentialsId, endpoint = ":version/projects/:projectId/onprem/distribution/credentials/:credentialsId") {
+    return __awaiter9(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, credentialsId });
+        const result = yield this.get(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  createCredentials(projectId, options, endpoint = ":version/projects/:projectId/onprem/distribution/credentials") {
+    return __awaiter9(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId });
+        const body = JSON.stringify(options);
+        const result = yield this.post(requestUrl, body).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+  deleteCredentials(projectId, credentialsId, endpoint = ":version/projects/:projectId/onprem/distribution/credentials/:credentialsId") {
+    return __awaiter9(this, undefined, undefined, function* () {
+      try {
+        const requestUrl = this.getRequestUrl(endpoint, { projectId, credentialsId });
+        const result = yield this.delete(requestUrl).then((result2) => result2.json());
+        return { result, error: null };
+      } catch (error) {
+        if (isDeepgramError(error)) {
+          return { result: null, error };
+        }
+        throw error;
+      }
+    });
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/SpeakLiveClient.js
+class SpeakLiveClient extends AbstractLiveClient {
+  constructor(options, speakOptions = {}, endpoint = ":version/speak") {
+    super(options);
+    this.namespace = "speak";
+    this.connect(speakOptions, endpoint);
+  }
+  setupConnection() {
+    this.setupConnectionEvents({
+      Open: LiveTTSEvents.Open,
+      Close: LiveTTSEvents.Close,
+      Error: LiveTTSEvents.Error
+    });
+    if (this.conn) {
+      this.conn.onmessage = (event) => {
+        this.handleMessage(event);
+      };
+    }
+  }
+  handleTextMessage(data) {
+    if (data.type === LiveTTSEvents.Metadata) {
+      this.emit(LiveTTSEvents.Metadata, data);
+    } else if (data.type === LiveTTSEvents.Flushed) {
+      this.emit(LiveTTSEvents.Flushed, data);
+    } else if (data.type === LiveTTSEvents.Warning) {
+      this.emit(LiveTTSEvents.Warning, data);
+    } else {
+      this.emit(LiveTTSEvents.Unhandled, data);
+    }
+  }
+  handleBinaryMessage(data) {
+    this.emit(LiveTTSEvents.Audio, data);
+  }
+  sendText(text) {
+    this.send(JSON.stringify({
+      type: "Speak",
+      text
+    }));
+  }
+  flush() {
+    this.send(JSON.stringify({
+      type: "Flush"
+    }));
+  }
+  clear() {
+    this.send(JSON.stringify({
+      type: "Clear"
+    }));
+  }
+  requestClose() {
+    this.send(JSON.stringify({
+      type: "Close"
+    }));
+  }
+  handleMessage(event) {
+    var _a, _b, _c, _d, _e, _f;
+    if (typeof event.data === "string") {
+      try {
+        const data = JSON.parse(event.data);
+        this.handleTextMessage(data);
+      } catch (error) {
+        this.emit(LiveTTSEvents.Error, {
+          event,
+          message: "Unable to parse `data` as JSON.",
+          error,
+          url: (_a = this.conn) === null || _a === undefined ? undefined : _a.url,
+          readyState: (_b = this.conn) === null || _b === undefined ? undefined : _b.readyState,
+          data: ((_c = event.data) === null || _c === undefined ? undefined : _c.toString().substring(0, 200)) + (((_d = event.data) === null || _d === undefined ? undefined : _d.toString().length) > 200 ? "..." : "")
+        });
+      }
+    } else if (event.data instanceof Blob) {
+      event.data.arrayBuffer().then((buffer) => {
+        this.handleBinaryMessage(Buffer.from(buffer));
+      });
+    } else if (event.data instanceof ArrayBuffer) {
+      this.handleBinaryMessage(Buffer.from(event.data));
+    } else if (Buffer.isBuffer(event.data)) {
+      this.handleBinaryMessage(event.data);
+    } else {
+      console.log("Received unknown data type", event.data);
+      this.emit(LiveTTSEvents.Error, {
+        event,
+        message: "Received unknown data type.",
+        url: (_e = this.conn) === null || _e === undefined ? undefined : _e.url,
+        readyState: (_f = this.conn) === null || _f === undefined ? undefined : _f.readyState,
+        dataType: typeof event.data
+      });
+    }
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/SpeakRestClient.js
+var __awaiter10 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+class SpeakRestClient extends AbstractRestClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "speak";
+  }
+  request(source, options, endpoint = ":version/speak") {
+    return __awaiter10(this, undefined, undefined, function* () {
+      let body;
+      if (isTextSource(source)) {
+        body = JSON.stringify(source);
+      } else {
+        throw new DeepgramError("Unknown transcription source type");
+      }
+      const requestUrl = this.getRequestUrl(endpoint, {}, Object.assign({ model: "aura-2-thalia-en" }, options));
+      this.result = yield this.post(requestUrl, body, {
+        headers: { Accept: "audio/*", "Content-Type": "application/json" }
+      });
+      return this;
+    });
+  }
+  getStream() {
+    return __awaiter10(this, undefined, undefined, function* () {
+      if (!this.result)
+        throw new DeepgramUnknownError("Tried to get stream before making request", "");
+      return this.result.body;
+    });
+  }
+  getHeaders() {
+    return __awaiter10(this, undefined, undefined, function* () {
+      if (!this.result)
+        throw new DeepgramUnknownError("Tried to get headers before making request", "");
+      return this.result.headers;
+    });
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/packages/SpeakClient.js
+class SpeakClient extends AbstractClient {
+  constructor() {
+    super(...arguments);
+    this.namespace = "speak";
+  }
+  request(source, options, endpoint = ":version/speak") {
+    const client = new SpeakRestClient(this.options);
+    return client.request(source, options, endpoint);
+  }
+  live(ttsOptions = {}, endpoint = ":version/speak") {
+    return new SpeakLiveClient(this.options, ttsOptions, endpoint);
+  }
+}
+
+// node_modules/@deepgram/sdk/dist/module/DeepgramClient.js
+class DeepgramClient extends AbstractClient {
+  get auth() {
+    return new AuthRestClient(this.options);
+  }
+  get listen() {
+    return new ListenClient(this.options);
+  }
+  get manage() {
+    return new ManageRestClient(this.options);
+  }
+  get models() {
+    return new ModelsRestClient(this.options);
+  }
+  get onprem() {
+    return this.selfhosted;
+  }
+  get selfhosted() {
+    return new SelfHostedRestClient(this.options);
+  }
+  get read() {
+    return new ReadRestClient(this.options);
+  }
+  get speak() {
+    return new SpeakClient(this.options);
+  }
+  agent(endpoint = "/:version/agent/converse") {
+    return new AgentLiveClient(this.options, endpoint);
+  }
+  get transcription() {
+    throw new DeepgramVersionError;
+  }
+  get projects() {
+    throw new DeepgramVersionError;
+  }
+  get keys() {
+    throw new DeepgramVersionError;
+  }
+  get members() {
+    throw new DeepgramVersionError;
+  }
+  get scopes() {
+    throw new DeepgramVersionError;
+  }
+  get invitation() {
+    throw new DeepgramVersionError;
+  }
+  get usage() {
+    throw new DeepgramVersionError;
+  }
+  get billing() {
+    throw new DeepgramVersionError;
+  }
+}
+// node_modules/@deepgram/sdk/dist/module/index.js
+function createClient(keyOrOptions, options) {
+  let resolvedOptions = {};
+  if (typeof keyOrOptions === "string" || typeof keyOrOptions === "function") {
+    if (typeof options === "object") {
+      resolvedOptions = options;
+    }
+    resolvedOptions.key = keyOrOptions;
+  } else if (typeof keyOrOptions === "object") {
+    resolvedOptions = keyOrOptions;
+  }
+  return new DeepgramClient(resolvedOptions);
+}
+
+// src/deepgram.ts
+var createListenerMap = () => ({
+  close: new Set,
+  endOfTurn: new Set,
+  error: new Set,
+  final: new Set,
+  partial: new Set
+});
+var emit = async (listeners, event, payload) => {
+  for (const listener of listeners[event]) {
+    await listener(payload);
+  }
+};
+var normalizeWords = (words) => {
+  if (!Array.isArray(words) || words.length === 0) {
+    return {};
+  }
+  const first = words[0];
+  const last = words.at(-1);
+  return {
+    endedAtMs: typeof last?.end === "number" ? Math.round(last.end * 1000) : undefined,
+    startedAtMs: typeof first?.start === "number" ? Math.round(first.start * 1000) : undefined
+  };
+};
+var buildTranscript = (payload, vendor) => {
+  const channel = payload.channel && typeof payload.channel === "object" ? payload.channel : null;
+  const alternatives = Array.isArray(channel?.alternatives) ? channel?.alternatives : [];
+  const alternative = alternatives[0];
+  if (!alternative || typeof alternative.transcript !== "string") {
+    return null;
+  }
+  return {
+    ...normalizeWords(Array.isArray(alternative.words) ? alternative.words : undefined),
+    confidence: typeof alternative.confidence === "number" ? alternative.confidence : undefined,
+    id: crypto.randomUUID(),
+    isFinal: payload.is_final === true,
+    language: typeof payload.language === "string" ? payload.language : undefined,
+    text: alternative.transcript,
+    vendor
+  };
+};
+var buildLiveOptions = (config, format) => {
+  const options = {
+    channels: format.channels,
+    encoding: "linear16",
+    interim_results: config.interimResults ?? true,
+    model: config.model,
+    punctuate: config.punctuate,
+    sample_rate: format.sampleRateHz,
+    smart_format: config.smartFormat
+  };
+  if (!String(config.model).startsWith("flux")) {
+    options.endpointing = config.endpointing ?? 300;
+    options.language = config.language;
+    options.utterance_end_ms = config.utteranceEndMs;
+    options.vad_events = config.vadEvents;
+  } else {
+    options.eager_eot_threshold = config.eagerEotThreshold;
+    options.eot_threshold = config.eotThreshold;
+    options.eot_timeout_ms = config.eotTimeoutMs;
+  }
+  if (config.diarize !== undefined) {
+    options.diarize = config.diarize;
+  }
+  if (config.numerals !== undefined) {
+    options.numerals = config.numerals;
+  }
+  if (config.profanityFilter !== undefined) {
+    options.profanity_filter = config.profanityFilter;
+  }
+  if (config.redact !== undefined) {
+    options.redact = config.redact;
+  }
+  if (config.tag !== undefined) {
+    options.tag = config.tag;
+  }
+  if (config.extra) {
+    options.extra = config.extra;
+  }
+  const keyterm = config.keyterms ?? config.keyterm;
+  if (keyterm !== undefined) {
+    options.keyterm = keyterm;
+  }
+  return options;
+};
+var openConnection = (client, config, liveOptions) => {
+  const listen = client.listen;
+  if (String(config.model).startsWith("flux") && listen && "v2" in listen && listen.v2 && typeof listen.v2.connect === "function") {
+    return listen.v2.connect(liveOptions);
+  }
+  if (listen && typeof listen.live === "function") {
+    return listen.live(liveOptions);
+  }
+  if (listen && "v1" in listen && listen.v1 && typeof listen.v1.connect === "function") {
+    return listen.v1.connect(liveOptions);
+  }
+  throw new Error("Unsupported Deepgram SDK live transcription surface");
+};
+var deepgram = (config) => ({
+  kind: "stt",
+  open: (options) => {
+    const client = createClient(config.apiKey);
+    const listeners = createListenerMap();
+    const liveOptions = buildLiveOptions(config, {
+      channels: options.format.channels,
+      sampleRateHz: options.format.sampleRateHz
+    });
+    const connection = openConnection(client, config, liveOptions);
+    const keepAliveMs = config.keepAliveMs ?? 4000;
+    let keepAliveTimer = null;
+    const clearKeepAlive = () => {
+      if (!keepAliveTimer) {
+        return;
+      }
+      clearInterval(keepAliveTimer);
+      keepAliveTimer = null;
+    };
+    connection.on(LiveTranscriptionEvents.Open, () => {
+      clearKeepAlive();
+      keepAliveTimer = setInterval(() => {
+        try {
+          connection.send(JSON.stringify({ type: "KeepAlive" }));
+        } catch {
+          clearKeepAlive();
+        }
+      }, keepAliveMs);
+    });
+    connection.on(LiveTranscriptionEvents.Transcript, (payload) => {
+      const type = typeof payload.type === "string" ? payload.type : "Results";
+      if (type === "UtteranceEnd" || type === "EndOfTurn" || type === "EagerEndOfTurn") {
+        emit(listeners, "endOfTurn", {
+          receivedAt: Date.now(),
+          reason: "vendor",
+          type: "endOfTurn"
+        });
+        return;
+      }
+      if (type === "TurnResumed") {
+        return;
+      }
+      const transcript = buildTranscript(payload, "deepgram");
+      if (!transcript || !transcript.text.trim()) {
+        return;
+      }
+      if (payload.is_final === true) {
+        emit(listeners, "final", {
+          receivedAt: Date.now(),
+          transcript: {
+            ...transcript,
+            isFinal: true
+          },
+          type: "final"
+        });
+      } else {
+        emit(listeners, "partial", {
+          receivedAt: Date.now(),
+          transcript: {
+            ...transcript,
+            isFinal: false
+          },
+          type: "partial"
+        });
+      }
+      if (payload.speech_final === true) {
+        emit(listeners, "endOfTurn", {
+          receivedAt: Date.now(),
+          reason: "vendor",
+          type: "endOfTurn"
+        });
+      }
+    });
+    connection.on(LiveTranscriptionEvents.Error, (error) => {
+      clearKeepAlive();
+      const resolvedError = error instanceof Error ? error : new Error(typeof error.toString === "function" ? String(error) : "Deepgram stream error");
+      emit(listeners, "error", {
+        error: resolvedError,
+        recoverable: false,
+        type: "error"
+      });
+    });
+    connection.on(LiveTranscriptionEvents.Close, (event) => {
+      clearKeepAlive();
+      emit(listeners, "close", {
+        code: event?.code,
+        reason: event?.reason,
+        recoverable: true,
+        type: "close"
+      });
+    });
+    return {
+      close: async (reason) => {
+        clearKeepAlive();
+        try {
+          connection.send(JSON.stringify({ type: "CloseStream" }));
+        } catch {}
+        if (typeof connection.finish === "function") {
+          await connection.finish();
+        } else if (typeof connection.requestClose === "function") {
+          connection.requestClose();
+        } else if (typeof connection.close === "function") {
+          connection.close(1000, reason);
+        }
+      },
+      on: (event, handler) => {
+        listeners[event].add(handler);
+        return () => {
+          listeners[event].delete(handler);
+        };
+      },
+      send: async (audio) => {
+        connection.send(audio);
+      }
+    };
+  }
+});
+export {
+  deepgram
+};