hume 0.5.8 → 0.5.9

package/README.md

@@ -92,12 +92,10 @@ for (const sample of samples) {
 ```
 
 ### Empathic Voice
-The SDK supports sending and receiving audio from Empathic Voice. If you're 
-running with Node.js you can also import our `ffplay` function which will 
-play the audio for you.  
+The SDK supports sending and receiving audio from Empathic Voice. 
 
 ```typescript
-import { HumeClient, ffplay } from "hume";
+import { HumeClient } from "hume";
 
 const hume = new HumeClient({
     apiKey: "<>",
@@ -108,7 +106,7 @@ const socket = await hume.empathicVoice.chat.connect({
     async onMessage(message): Promise<void> {
         if (message.type === "audio_output") {
             const decoded = Buffer.from(message.data, "base64");
-            await ffplay(decoded);
+            // play decoded message
         }
     }
 });

package/dist/wrapper/convertBase64ToBlob.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a base64-encoded string into a `Blob` object with the specified content type.
+ *
+ * @param {string} base64 - The base64-encoded string representing binary data.
+ * @param {string} contentType - The MIME type to assign to the resulting `Blob`.
+ * @returns {Blob} A `Blob` object containing the binary data from the base64 string.
+ */
+export declare function convertBase64ToBlob(base64: string, contentType: string): Blob;

package/dist/wrapper/convertBase64ToBlob.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBase64ToBlob = void 0;
+/**
+ * Converts a base64-encoded string into a `Blob` object with the specified content type.
+ *
+ * @param {string} base64 - The base64-encoded string representing binary data.
+ * @param {string} contentType - The MIME type to assign to the resulting `Blob`.
+ * @returns {Blob} A `Blob` object containing the binary data from the base64 string.
+ */
+function convertBase64ToBlob(base64, contentType) {
+    // Decode base64 string to a binary string
+    const binaryString = window.atob(base64);
+    // Create a Uint8Array with the same length as the binary string
+    const byteArray = new Uint8Array(binaryString.length);
+    // Fill the Uint8Array by converting each character's Unicode value to a byte
+    for (let i = 0; i < binaryString.length; i++) {
+        byteArray[i] = binaryString.charCodeAt(i);
+    }
+    // Create and return a Blob with the specified content type
+    return new Blob([byteArray], { type: contentType });
+}
+exports.convertBase64ToBlob = convertBase64ToBlob;

package/dist/wrapper/convertBlobToBase64.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a `Blob` object into a base64-encoded string.
+ * The resulting string contains the binary data from the `Blob`.
+ *
+ * @param {Blob} blob - The `Blob` object to convert to base64.
+ * @returns {Promise<string>} A promise that resolves to a base64-encoded string representing the `Blob` data.
+ */
+export declare function convertBlobToBase64(blob: Blob): Promise<string>;

package/dist/wrapper/convertBlobToBase64.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBlobToBase64 = void 0;
+/**
+ * Converts a `Blob` object into a base64-encoded string.
+ * The resulting string contains the binary data from the `Blob`.
+ *
+ * @param {Blob} blob - The `Blob` object to convert to base64.
+ * @returns {Promise<string>} A promise that resolves to a base64-encoded string representing the `Blob` data.
+ */
+function convertBlobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        // Handle the load event which is triggered when readAsDataURL completes
+        reader.onloadend = () => {
+            // Ensure reader.result is not null and is a string
+            if (typeof reader.result === "string") {
+                // Extract the Base64 encoded string, skipping the data URL prefix (e.g., "data:image/png;base64,")
+                const base64Data = reader.result.split(",")[1];
+                if (base64Data) {
+                    resolve(base64Data);
+                }
+                else {
+                    reject(new Error("Failed to split the result into Base64 data."));
+                }
+            }
+            else {
+                reject(new Error("FileReader result is null or not a string."));
+            }
+        };
+        // Handle errors during the read process
+        reader.onerror = () => {
+            var _a;
+            reject(new Error(`Error reading blob: ${(_a = reader.error) === null || _a === void 0 ? void 0 : _a.message}`));
+        };
+        // Initiate reading the blob as a data URL
+        reader.readAsDataURL(blob);
+    });
+}
+exports.convertBlobToBase64 = convertBlobToBase64;

package/dist/wrapper/empathicVoice/chat/ChatClient.js

@@ -135,7 +135,6 @@ function parse(data, args = {}) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         const message = JSON.parse(data);
-        console.log(message);
         const parsedResponse = yield serializers.empathicVoice.SubscribeEvent.parse(message, {
             unrecognizedObjectKeys: "passthrough",
             allowUnrecognizedUnionMembers: true,

package/dist/wrapper/empathicVoice/chat/StreamSocket.d.ts

@@ -14,11 +14,11 @@ export declare class StreamSocket {
     /**
      * Send session settings
      */
-    sendSessionSettings(message: Hume.empathicVoice.SessionSettings): Promise<void>;
+    sendSessionSettings(message: Omit<Hume.empathicVoice.SessionSettings, "type">): Promise<void>;
     /**
      * Send session settings
      */
-    sendAssistantInput(message: Hume.empathicVoice.AssistantInput): Promise<void>;
+    sendAssistantInput(message: Omit<Hume.empathicVoice.AssistantInput, "type">): Promise<void>;
     /**
      * Send text input
      */

package/dist/wrapper/empathicVoice/chat/StreamSocket.js

@@ -51,7 +51,7 @@ class StreamSocket {
      */
     sendSessionSettings(message) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendJson(message);
+            yield this.sendJson(Object.assign({ type: "session_settings" }, message));
         });
     }
     /**
@@ -59,7 +59,7 @@ class StreamSocket {
      */
     sendAssistantInput(message) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendJson(message);
+            yield this.sendJson(Object.assign(Object.assign({}, message), { type: "assistant_input" }));
         });
     }
     /**

package/dist/wrapper/ensureSingleValidAudioTrack.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ensures that the given media stream contains exactly one valid audio track.
+ * Throws an error if no audio tracks are found, if there is more than one audio track,
+ * or if the sole audio track is falsy.
+ *
+ * @param {MediaStream} stream - The media stream object containing audio tracks to validate.
+ * @throws {Error} "No audio tracks" if the stream contains zero audio tracks.
+ * @throws {Error} "Multiple audio tracks" if the stream contains more than one audio track.
+ * @throws {Error} "No audio track" if the sole audio track is falsy.
+ */
+export declare const ensureSingleValidAudioTrack: (stream: MediaStream) => void;

package/dist/wrapper/ensureSingleValidAudioTrack.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureSingleValidAudioTrack = void 0;
+/**
+ * Ensures that the given media stream contains exactly one valid audio track.
+ * Throws an error if no audio tracks are found, if there is more than one audio track,
+ * or if the sole audio track is falsy.
+ *
+ * @param {MediaStream} stream - The media stream object containing audio tracks to validate.
+ * @throws {Error} "No audio tracks" if the stream contains zero audio tracks.
+ * @throws {Error} "Multiple audio tracks" if the stream contains more than one audio track.
+ * @throws {Error} "No audio track" if the sole audio track is falsy.
+ */
+const ensureSingleValidAudioTrack = (stream) => {
+    const tracks = stream.getAudioTracks();
+    if (tracks.length === 0) {
+        throw new Error("No audio tracks available");
+    }
+    else if (tracks.length > 1) {
+        throw new Error("Multiple audio tracks found");
+    }
+    else if (!tracks[0]) {
+        throw new Error("The audio track is invalid");
+    }
+};
+exports.ensureSingleValidAudioTrack = ensureSingleValidAudioTrack;

package/dist/wrapper/getAudioStream.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Requests an audio stream from the user's device using the `getUserMedia` API.
+ * The stream will have echo cancellation, noise suppression, and auto gain control enabled.
+ *
+ * @returns {Promise<MediaStream>} A promise that resolves to a `MediaStream` containing audio data only.
+ * @throws {DOMException} If the user denies access or no audio input devices are found.
+ */
+export declare const getAudioStream: () => Promise<MediaStream>;

package/dist/wrapper/getAudioStream.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioStream = void 0;
+/**
+ * Requests an audio stream from the user's device using the `getUserMedia` API.
+ * The stream will have echo cancellation, noise suppression, and auto gain control enabled.
+ *
+ * @returns {Promise<MediaStream>} A promise that resolves to a `MediaStream` containing audio data only.
+ * @throws {DOMException} If the user denies access or no audio input devices are found.
+ */
+const getAudioStream = () => __awaiter(void 0, void 0, void 0, function* () {
+    return navigator.mediaDevices.getUserMedia({
+        audio: {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true,
+        },
+        video: false,
+    });
+});
+exports.getAudioStream = getAudioStream;

package/dist/wrapper/getBrowserSupportedMimeType.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Enum representing the supported MIME types for audio recording.
+ */
+export declare enum MimeType {
+    WEBM = "audio/webm",
+    MP4 = "audio/mp4",
+    WAV = "audio/wav"
+}
+/**
+ * Represents a successful result where a compatible MIME type was found.
+ * @property {true} success - Indicates a successful result.
+ * @property {MimeType} mimeType - The MIME type supported by the browser.
+ */
+declare type MimeTypeSuccessResult = {
+    success: true;
+    mimeType: MimeType;
+};
+/**
+ * Represents a failure result when no compatible MIME type is supported or an error occurs.
+ * @property {false} success - Indicates a failure result.
+ * @property {Error} error - The error explaining why a compatible MIME type was not found.
+ */
+declare type MimeTypeFailureResult = {
+    success: false;
+    error: Error;
+};
+/**
+ * Union type representing the possible outcomes of checking for a supported MIME type.
+ * Could either be a successful or failure result.
+ */
+declare type MimeTypeResult = MimeTypeSuccessResult | MimeTypeFailureResult;
+/**
+ * Determines if the current browser supports any of the predefined audio MIME types
+ * (WEBM, MP4, or WAV) via the `MediaRecorder` API.
+ *
+ * @returns {MimeTypeResult} An object containing the success status and either a supported MIME type or an error.
+ * @throws {Error} If the `MediaRecorder` API is not supported by the browser or no compatible types are found.
+ */
+export declare function getBrowserSupportedMimeType(): MimeTypeResult;
+export {};

package/dist/wrapper/getBrowserSupportedMimeType.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserSupportedMimeType = exports.MimeType = void 0;
+/**
+ * Enum representing the supported MIME types for audio recording.
+ */
+var MimeType;
+(function (MimeType) {
+    MimeType["WEBM"] = "audio/webm";
+    MimeType["MP4"] = "audio/mp4";
+    MimeType["WAV"] = "audio/wav";
+})(MimeType = exports.MimeType || (exports.MimeType = {}));
+/**
+ * Checks whether the `MediaRecorder` API is supported in the current environment.
+ *
+ * @returns {boolean} Returns `true` if the `MediaRecorder` API is supported, otherwise `false`.
+ */
+function isMediaRecorderSupported() {
+    return typeof MediaRecorder !== "undefined";
+}
+/**
+ * Finds and returns the first MIME type from the given array that is supported by the `MediaRecorder`.
+ *
+ * @param {MimeType[]} mimeTypes - An array of MIME types to check for compatibility.
+ * @returns {MimeType | null} The first supported MIME type or `null` if none are supported.
+ */
+function getSupportedMimeType(mimeTypes) {
+    return mimeTypes.find((type) => MediaRecorder.isTypeSupported(type)) || null;
+}
+/**
+ * Determines if the current browser supports any of the predefined audio MIME types
+ * (WEBM, MP4, or WAV) via the `MediaRecorder` API.
+ *
+ * @returns {MimeTypeResult} An object containing the success status and either a supported MIME type or an error.
+ * @throws {Error} If the `MediaRecorder` API is not supported by the browser or no compatible types are found.
+ */
+function getBrowserSupportedMimeType() {
+    // Check if the MediaRecorder API is supported in the current environment.
+    if (!isMediaRecorderSupported()) {
+        return {
+            success: false,
+            error: new Error("MediaRecorder is not supported"),
+        };
+    }
+    const COMPATIBLE_MIME_TYPES = [MimeType.WEBM, MimeType.MP4, MimeType.WAV];
+    // Find the first compatible MIME type that the browser's MediaRecorder supports.
+    const supportedMimeType = getSupportedMimeType(COMPATIBLE_MIME_TYPES);
+    // If no compatible MIME type is found, return a failure result with an appropriate error message.
+    if (!supportedMimeType) {
+        return {
+            success: false,
+            error: new Error("Browser does not support any compatible mime types"),
+        };
+    }
+    // If a compatible MIME type is found, return a success result with the supported MIME type.
+    return {
+        success: true,
+        mimeType: supportedMimeType,
+    };
+}
+exports.getBrowserSupportedMimeType = getBrowserSupportedMimeType;

package/dist/wrapper/index.d.ts

@@ -1,3 +1,8 @@
 export { base64Decode } from "./base64Decode";
 export { base64Encode } from "./base64Encode";
+export { convertBase64ToBlob } from "./convertBase64ToBlob";
+export { convertBlobToBase64 } from "./convertBlobToBase64";
+export { ensureSingleValidAudioTrack } from "./ensureSingleValidAudioTrack";
+export { getAudioStream } from "./getAudioStream";
+export { MimeType, getBrowserSupportedMimeType } from "./getBrowserSupportedMimeType";
 export { HumeClient } from "./HumeClient";

package/dist/wrapper/index.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HumeClient = exports.base64Encode = exports.base64Decode = void 0;
+exports.HumeClient = exports.getBrowserSupportedMimeType = exports.MimeType = exports.getAudioStream = exports.ensureSingleValidAudioTrack = exports.convertBlobToBase64 = exports.convertBase64ToBlob = exports.base64Encode = exports.base64Decode = void 0;
 var base64Decode_1 = require("./base64Decode");
 Object.defineProperty(exports, "base64Decode", { enumerable: true, get: function () { return base64Decode_1.base64Decode; } });
 var base64Encode_1 = require("./base64Encode");
 Object.defineProperty(exports, "base64Encode", { enumerable: true, get: function () { return base64Encode_1.base64Encode; } });
+var convertBase64ToBlob_1 = require("./convertBase64ToBlob");
+Object.defineProperty(exports, "convertBase64ToBlob", { enumerable: true, get: function () { return convertBase64ToBlob_1.convertBase64ToBlob; } });
+var convertBlobToBase64_1 = require("./convertBlobToBase64");
+Object.defineProperty(exports, "convertBlobToBase64", { enumerable: true, get: function () { return convertBlobToBase64_1.convertBlobToBase64; } });
+var ensureSingleValidAudioTrack_1 = require("./ensureSingleValidAudioTrack");
+Object.defineProperty(exports, "ensureSingleValidAudioTrack", { enumerable: true, get: function () { return ensureSingleValidAudioTrack_1.ensureSingleValidAudioTrack; } });
+var getAudioStream_1 = require("./getAudioStream");
+Object.defineProperty(exports, "getAudioStream", { enumerable: true, get: function () { return getAudioStream_1.getAudioStream; } });
+var getBrowserSupportedMimeType_1 = require("./getBrowserSupportedMimeType");
+Object.defineProperty(exports, "MimeType", { enumerable: true, get: function () { return getBrowserSupportedMimeType_1.MimeType; } });
+Object.defineProperty(exports, "getBrowserSupportedMimeType", { enumerable: true, get: function () { return getBrowserSupportedMimeType_1.getBrowserSupportedMimeType; } });
 var HumeClient_1 = require("./HumeClient");
 Object.defineProperty(exports, "HumeClient", { enumerable: true, get: function () { return HumeClient_1.HumeClient; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hume",
-    "version": "0.5.8",
+    "version": "0.5.9",
     "private": false,
     "repository": "https://github.com/HumeAI/hume-typescript-sdk",
     "main": "./index.js",
@@ -32,4 +32,4 @@
         "@types/ws": "^8.5.9",
         "@types/uuid": "9.0.7"
     }
-}
+}

package/wrapper/convertBase64ToBlob.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a base64-encoded string into a `Blob` object with the specified content type.
+ *
+ * @param {string} base64 - The base64-encoded string representing binary data.
+ * @param {string} contentType - The MIME type to assign to the resulting `Blob`.
+ * @returns {Blob} A `Blob` object containing the binary data from the base64 string.
+ */
+export declare function convertBase64ToBlob(base64: string, contentType: string): Blob;

package/wrapper/convertBase64ToBlob.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBase64ToBlob = void 0;
+/**
+ * Converts a base64-encoded string into a `Blob` object with the specified content type.
+ *
+ * @param {string} base64 - The base64-encoded string representing binary data.
+ * @param {string} contentType - The MIME type to assign to the resulting `Blob`.
+ * @returns {Blob} A `Blob` object containing the binary data from the base64 string.
+ */
+function convertBase64ToBlob(base64, contentType) {
+    // Decode base64 string to a binary string
+    const binaryString = window.atob(base64);
+    // Create a Uint8Array with the same length as the binary string
+    const byteArray = new Uint8Array(binaryString.length);
+    // Fill the Uint8Array by converting each character's Unicode value to a byte
+    for (let i = 0; i < binaryString.length; i++) {
+        byteArray[i] = binaryString.charCodeAt(i);
+    }
+    // Create and return a Blob with the specified content type
+    return new Blob([byteArray], { type: contentType });
+}
+exports.convertBase64ToBlob = convertBase64ToBlob;

package/wrapper/convertBlobToBase64.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a `Blob` object into a base64-encoded string.
+ * The resulting string contains the binary data from the `Blob`.
+ *
+ * @param {Blob} blob - The `Blob` object to convert to base64.
+ * @returns {Promise<string>} A promise that resolves to a base64-encoded string representing the `Blob` data.
+ */
+export declare function convertBlobToBase64(blob: Blob): Promise<string>;

package/wrapper/convertBlobToBase64.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBlobToBase64 = void 0;
+/**
+ * Converts a `Blob` object into a base64-encoded string.
+ * The resulting string contains the binary data from the `Blob`.
+ *
+ * @param {Blob} blob - The `Blob` object to convert to base64.
+ * @returns {Promise<string>} A promise that resolves to a base64-encoded string representing the `Blob` data.
+ */
+function convertBlobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        // Handle the load event which is triggered when readAsDataURL completes
+        reader.onloadend = () => {
+            // Ensure reader.result is not null and is a string
+            if (typeof reader.result === "string") {
+                // Extract the Base64 encoded string, skipping the data URL prefix (e.g., "data:image/png;base64,")
+                const base64Data = reader.result.split(",")[1];
+                if (base64Data) {
+                    resolve(base64Data);
+                }
+                else {
+                    reject(new Error("Failed to split the result into Base64 data."));
+                }
+            }
+            else {
+                reject(new Error("FileReader result is null or not a string."));
+            }
+        };
+        // Handle errors during the read process
+        reader.onerror = () => {
+            var _a;
+            reject(new Error(`Error reading blob: ${(_a = reader.error) === null || _a === void 0 ? void 0 : _a.message}`));
+        };
+        // Initiate reading the blob as a data URL
+        reader.readAsDataURL(blob);
+    });
+}
+exports.convertBlobToBase64 = convertBlobToBase64;

package/wrapper/empathicVoice/chat/ChatClient.js

@@ -135,7 +135,6 @@ function parse(data, args = {}) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         const message = JSON.parse(data);
-        console.log(message);
         const parsedResponse = yield serializers.empathicVoice.SubscribeEvent.parse(message, {
             unrecognizedObjectKeys: "passthrough",
             allowUnrecognizedUnionMembers: true,

package/wrapper/empathicVoice/chat/StreamSocket.d.ts

@@ -14,11 +14,11 @@ export declare class StreamSocket {
     /**
      * Send session settings
      */
-    sendSessionSettings(message: Hume.empathicVoice.SessionSettings): Promise<void>;
+    sendSessionSettings(message: Omit<Hume.empathicVoice.SessionSettings, "type">): Promise<void>;
     /**
      * Send session settings
      */
-    sendAssistantInput(message: Hume.empathicVoice.AssistantInput): Promise<void>;
+    sendAssistantInput(message: Omit<Hume.empathicVoice.AssistantInput, "type">): Promise<void>;
     /**
      * Send text input
      */

package/wrapper/empathicVoice/chat/StreamSocket.js

@@ -51,7 +51,7 @@ class StreamSocket {
      */
     sendSessionSettings(message) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendJson(message);
+            yield this.sendJson(Object.assign({ type: "session_settings" }, message));
         });
     }
     /**
@@ -59,7 +59,7 @@ class StreamSocket {
      */
     sendAssistantInput(message) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendJson(message);
+            yield this.sendJson(Object.assign(Object.assign({}, message), { type: "assistant_input" }));
         });
     }
     /**

package/wrapper/ensureSingleValidAudioTrack.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ensures that the given media stream contains exactly one valid audio track.
+ * Throws an error if no audio tracks are found, if there is more than one audio track,
+ * or if the sole audio track is falsy.
+ *
+ * @param {MediaStream} stream - The media stream object containing audio tracks to validate.
+ * @throws {Error} "No audio tracks" if the stream contains zero audio tracks.
+ * @throws {Error} "Multiple audio tracks" if the stream contains more than one audio track.
+ * @throws {Error} "No audio track" if the sole audio track is falsy.
+ */
+export declare const ensureSingleValidAudioTrack: (stream: MediaStream) => void;

package/wrapper/ensureSingleValidAudioTrack.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureSingleValidAudioTrack = void 0;
+/**
+ * Ensures that the given media stream contains exactly one valid audio track.
+ * Throws an error if no audio tracks are found, if there is more than one audio track,
+ * or if the sole audio track is falsy.
+ *
+ * @param {MediaStream} stream - The media stream object containing audio tracks to validate.
+ * @throws {Error} "No audio tracks" if the stream contains zero audio tracks.
+ * @throws {Error} "Multiple audio tracks" if the stream contains more than one audio track.
+ * @throws {Error} "No audio track" if the sole audio track is falsy.
+ */
+const ensureSingleValidAudioTrack = (stream) => {
+    const tracks = stream.getAudioTracks();
+    if (tracks.length === 0) {
+        throw new Error("No audio tracks available");
+    }
+    else if (tracks.length > 1) {
+        throw new Error("Multiple audio tracks found");
+    }
+    else if (!tracks[0]) {
+        throw new Error("The audio track is invalid");
+    }
+};
+exports.ensureSingleValidAudioTrack = ensureSingleValidAudioTrack;

package/wrapper/getAudioStream.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Requests an audio stream from the user's device using the `getUserMedia` API.
+ * The stream will have echo cancellation, noise suppression, and auto gain control enabled.
+ *
+ * @returns {Promise<MediaStream>} A promise that resolves to a `MediaStream` containing audio data only.
+ * @throws {DOMException} If the user denies access or no audio input devices are found.
+ */
+export declare const getAudioStream: () => Promise<MediaStream>;

package/wrapper/getAudioStream.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioStream = void 0;
+/**
+ * Requests an audio stream from the user's device using the `getUserMedia` API.
+ * The stream will have echo cancellation, noise suppression, and auto gain control enabled.
+ *
+ * @returns {Promise<MediaStream>} A promise that resolves to a `MediaStream` containing audio data only.
+ * @throws {DOMException} If the user denies access or no audio input devices are found.
+ */
+const getAudioStream = () => __awaiter(void 0, void 0, void 0, function* () {
+    return navigator.mediaDevices.getUserMedia({
+        audio: {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true,
+        },
+        video: false,
+    });
+});
+exports.getAudioStream = getAudioStream;

package/wrapper/getBrowserSupportedMimeType.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Enum representing the supported MIME types for audio recording.
+ */
+export declare enum MimeType {
+    WEBM = "audio/webm",
+    MP4 = "audio/mp4",
+    WAV = "audio/wav"
+}
+/**
+ * Represents a successful result where a compatible MIME type was found.
+ * @property {true} success - Indicates a successful result.
+ * @property {MimeType} mimeType - The MIME type supported by the browser.
+ */
+declare type MimeTypeSuccessResult = {
+    success: true;
+    mimeType: MimeType;
+};
+/**
+ * Represents a failure result when no compatible MIME type is supported or an error occurs.
+ * @property {false} success - Indicates a failure result.
+ * @property {Error} error - The error explaining why a compatible MIME type was not found.
+ */
+declare type MimeTypeFailureResult = {
+    success: false;
+    error: Error;
+};
+/**
+ * Union type representing the possible outcomes of checking for a supported MIME type.
+ * Could either be a successful or failure result.
+ */
+declare type MimeTypeResult = MimeTypeSuccessResult | MimeTypeFailureResult;
+/**
+ * Determines if the current browser supports any of the predefined audio MIME types
+ * (WEBM, MP4, or WAV) via the `MediaRecorder` API.
+ *
+ * @returns {MimeTypeResult} An object containing the success status and either a supported MIME type or an error.
+ * @throws {Error} If the `MediaRecorder` API is not supported by the browser or no compatible types are found.
+ */
+export declare function getBrowserSupportedMimeType(): MimeTypeResult;
+export {};

package/wrapper/getBrowserSupportedMimeType.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserSupportedMimeType = exports.MimeType = void 0;
+/**
+ * Enum representing the supported MIME types for audio recording.
+ */
+var MimeType;
+(function (MimeType) {
+    MimeType["WEBM"] = "audio/webm";
+    MimeType["MP4"] = "audio/mp4";
+    MimeType["WAV"] = "audio/wav";
+})(MimeType = exports.MimeType || (exports.MimeType = {}));
+/**
+ * Checks whether the `MediaRecorder` API is supported in the current environment.
+ *
+ * @returns {boolean} Returns `true` if the `MediaRecorder` API is supported, otherwise `false`.
+ */
+function isMediaRecorderSupported() {
+    return typeof MediaRecorder !== "undefined";
+}
+/**
+ * Finds and returns the first MIME type from the given array that is supported by the `MediaRecorder`.
+ *
+ * @param {MimeType[]} mimeTypes - An array of MIME types to check for compatibility.
+ * @returns {MimeType | null} The first supported MIME type or `null` if none are supported.
+ */
+function getSupportedMimeType(mimeTypes) {
+    return mimeTypes.find((type) => MediaRecorder.isTypeSupported(type)) || null;
+}
+/**
+ * Determines if the current browser supports any of the predefined audio MIME types
+ * (WEBM, MP4, or WAV) via the `MediaRecorder` API.
+ *
+ * @returns {MimeTypeResult} An object containing the success status and either a supported MIME type or an error.
+ * @throws {Error} If the `MediaRecorder` API is not supported by the browser or no compatible types are found.
+ */
+function getBrowserSupportedMimeType() {
+    // Check if the MediaRecorder API is supported in the current environment.
+    if (!isMediaRecorderSupported()) {
+        return {
+            success: false,
+            error: new Error("MediaRecorder is not supported"),
+        };
+    }
+    const COMPATIBLE_MIME_TYPES = [MimeType.WEBM, MimeType.MP4, MimeType.WAV];
+    // Find the first compatible MIME type that the browser's MediaRecorder supports.
+    const supportedMimeType = getSupportedMimeType(COMPATIBLE_MIME_TYPES);
+    // If no compatible MIME type is found, return a failure result with an appropriate error message.
+    if (!supportedMimeType) {
+        return {
+            success: false,
+            error: new Error("Browser does not support any compatible mime types"),
+        };
+    }
+    // If a compatible MIME type is found, return a success result with the supported MIME type.
+    return {
+        success: true,
+        mimeType: supportedMimeType,
+    };
+}
+exports.getBrowserSupportedMimeType = getBrowserSupportedMimeType;

package/wrapper/index.d.ts

@@ -1,3 +1,8 @@
 export { base64Decode } from "./base64Decode";
 export { base64Encode } from "./base64Encode";
+export { convertBase64ToBlob } from "./convertBase64ToBlob";
+export { convertBlobToBase64 } from "./convertBlobToBase64";
+export { ensureSingleValidAudioTrack } from "./ensureSingleValidAudioTrack";
+export { getAudioStream } from "./getAudioStream";
+export { MimeType, getBrowserSupportedMimeType } from "./getBrowserSupportedMimeType";
 export { HumeClient } from "./HumeClient";

package/wrapper/index.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HumeClient = exports.base64Encode = exports.base64Decode = void 0;
+exports.HumeClient = exports.getBrowserSupportedMimeType = exports.MimeType = exports.getAudioStream = exports.ensureSingleValidAudioTrack = exports.convertBlobToBase64 = exports.convertBase64ToBlob = exports.base64Encode = exports.base64Decode = void 0;
 var base64Decode_1 = require("./base64Decode");
 Object.defineProperty(exports, "base64Decode", { enumerable: true, get: function () { return base64Decode_1.base64Decode; } });
 var base64Encode_1 = require("./base64Encode");
 Object.defineProperty(exports, "base64Encode", { enumerable: true, get: function () { return base64Encode_1.base64Encode; } });
+var convertBase64ToBlob_1 = require("./convertBase64ToBlob");
+Object.defineProperty(exports, "convertBase64ToBlob", { enumerable: true, get: function () { return convertBase64ToBlob_1.convertBase64ToBlob; } });
+var convertBlobToBase64_1 = require("./convertBlobToBase64");
+Object.defineProperty(exports, "convertBlobToBase64", { enumerable: true, get: function () { return convertBlobToBase64_1.convertBlobToBase64; } });
+var ensureSingleValidAudioTrack_1 = require("./ensureSingleValidAudioTrack");
+Object.defineProperty(exports, "ensureSingleValidAudioTrack", { enumerable: true, get: function () { return ensureSingleValidAudioTrack_1.ensureSingleValidAudioTrack; } });
+var getAudioStream_1 = require("./getAudioStream");
+Object.defineProperty(exports, "getAudioStream", { enumerable: true, get: function () { return getAudioStream_1.getAudioStream; } });
+var getBrowserSupportedMimeType_1 = require("./getBrowserSupportedMimeType");
+Object.defineProperty(exports, "MimeType", { enumerable: true, get: function () { return getBrowserSupportedMimeType_1.MimeType; } });
+Object.defineProperty(exports, "getBrowserSupportedMimeType", { enumerable: true, get: function () { return getBrowserSupportedMimeType_1.getBrowserSupportedMimeType; } });
 var HumeClient_1 = require("./HumeClient");
 Object.defineProperty(exports, "HumeClient", { enumerable: true, get: function () { return HumeClient_1.HumeClient; } });