hume 0.3.2 → 0.4.0

package/dist/wrapper/StreamSocket.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -8,9 +31,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamSocket = void 0;
-const promises_1 = require("fs/promises");
+const ws_1 = __importDefault(require("ws"));
+const uuid_1 = require("uuid");
+const HumeStreamingClient_1 = require("./HumeStreamingClient");
+const base64Encode_1 = require("./base64Encode");
+const serializers = __importStar(require("../serialization"));
+const errors = __importStar(require("../errors"));
+const fs = __importStar(require("fs"));
 class StreamSocket {
     constructor({ websocket, config, streamWindowMs }) {
         this.websocket = websocket;
@@ -18,33 +57,62 @@ class StreamSocket {
         this.streamWindowMs = streamWindowMs;
     }
     /**
-     * Send a file on the `StreamSocket`
+     * Send file on the `StreamSocket`
      *
-     * @param filepath Path to media file to send on socket connection
-     * @param config List of model configurations.
-     * If set these configurations will overwrite any configurations
-     * set when initializing the `StreamSocket`
+     * @param file A fs.ReadStream | File | Blob
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
      */
-    sendFile({ filepath, config, }) {
+    sendFile({ file, config, }) {
+        var file_1, file_1_1;
+        var e_1, _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.sendBuffer({
-                buffer: yield (0, promises_1.readFile)(filepath),
-                config,
-            });
-        });
-    }
-    /**
-     * Send raw bytes on the `StreamSocket`
-     *
-     * @param buffer Raw bytes of media to send on socket connection
-     * @param config List of model configurations.
-     * If set these configurations will overwrite any configurations
-     * set when initializing the `StreamSocket`
-     */
-    sendBuffer({ buffer, config, }) {
-        this.sendText({
-            text: buffer.toString("base64"),
-            config,
+            if (config != null) {
+                this.config = config;
+            }
+            let contents = "";
+            if (file instanceof fs.ReadStream) {
+                const chunks = [];
+                try {
+                    for (file_1 = __asyncValues(file); file_1_1 = yield file_1.next(), !file_1_1.done;) {
+                        const chunk = file_1_1.value;
+                        chunks.push(Buffer.from(chunk));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (file_1_1 && !file_1_1.done && (_a = file_1.return)) yield _a.call(file_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                contents = Buffer.concat(chunks).toString("base64");
+            }
+            else if (file instanceof Blob) {
+                const toBase64 = (file) => new Promise((res, err) => {
+                    const reader = new FileReader();
+                    reader.readAsDataURL(file);
+                    reader.onload = () => res(reader.result);
+                });
+                contents = yield toBase64(file);
+            }
+            else {
+                throw new errors.HumeError({ message: `file must be one of ReadStream or Blob.` });
+            }
+            const request = {
+                payloadId: (0, uuid_1.v4)(),
+                data: contents,
+                models: this.config,
+                rawText: false,
+            };
+            if (this.streamWindowMs != null) {
+                request.streamWindowMs = this.streamWindowMs;
+            }
+            const response = yield this.send(request);
+            if (response == null) {
+                throw new errors.HumeError({ message: `Received no response after sending file: ${file}` });
+            }
+            return response;
         });
     }
     /**
@@ -54,16 +122,26 @@ class StreamSocket {
      * @param config This method is intended for use with a `LanguageConfig`.
      * When the socket is configured for other modalities this method will fail.
      */
-    sendText({ text, config, }) {
-        if (config != null) {
-            this.config = config;
-        }
-        this.websocket.send(JSON.stringify({
-            data: text,
-            raw_text: true,
-            models: this.config,
-            stream_window_ms: this.streamWindowMs,
-        }));
+    sendText({ text, config }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (config != null) {
+                this.config = config;
+            }
+            const request = {
+                payloadId: (0, uuid_1.v4)(),
+                data: text,
+                rawText: true,
+                models: this.config,
+            };
+            if (this.streamWindowMs != null) {
+                request.streamWindowMs = this.streamWindowMs;
+            }
+            const response = yield this.send(request);
+            if (response == null) {
+                throw new errors.HumeError({ message: `Received no response after sending text: ${text}` });
+            }
+            return response;
+        });
     }
     /**
      * Send facemesh landmarks on the `StreamSocket`
@@ -76,10 +154,12 @@ class StreamSocket {
      * If set these configurations will overwrite existing configurations
      */
     sendFacemesh({ landmarks, config, }) {
-        const stringifiedLandmarks = JSON.stringify(landmarks);
-        this.sendText({
-            text: Buffer.from(stringifiedLandmarks).toString("base64"),
-            config,
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = this.sendText({
+                text: (0, base64Encode_1.base64Encode)(JSON.stringify(landmarks)),
+                config,
+            });
+            return response;
         });
     }
     /**
@@ -90,9 +170,11 @@ class StreamSocket {
      * streaming connection without leaking context across media samples.
      */
     reset() {
-        this.websocket.send(JSON.stringify({
-            reset_stream: true,
-        }));
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send({
+                resetStream: true,
+            });
+        });
     }
     /**
      *
@@ -100,9 +182,11 @@ class StreamSocket {
      *
      */
     getJobDetails() {
-        this.websocket.send(JSON.stringify({
-            job_details: true,
-        }));
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send({
+                jobDetails: true,
+            });
+        });
     }
     /**
      * Closes the underlying socket.
@@ -110,5 +194,48 @@ class StreamSocket {
     close() {
         this.websocket.close();
     }
+    send(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.tillSocketOpen();
+            const jsonPayload = yield serializers.ModelsInput.jsonOrThrow(payload, {
+                unrecognizedObjectKeys: "strip",
+            });
+            this.websocket.send(JSON.stringify(jsonPayload));
+            const response = yield new Promise((resolve, reject) => {
+                this.websocket.addEventListener("message", (event) => {
+                    const response = (0, HumeStreamingClient_1.parse)(event.data);
+                    resolve(response);
+                });
+            });
+            if (response != null && isError(response)) {
+                throw new errors.HumeError({ message: `CODE ${response.code}: ${response.error}` });
+            }
+            if (response != null && isWarning(response)) {
+                throw new errors.HumeError({ message: `CODE ${response.code}: ${response.warning}` });
+            }
+            return response;
+        });
+    }
+    tillSocketOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.websocket.readyState === ws_1.default.OPEN) {
+                return this.websocket;
+            }
+            return new Promise((resolve, reject) => {
+                this.websocket.addEventListener("open", () => {
+                    resolve(this.websocket);
+                });
+                this.websocket.addEventListener("error", (event) => {
+                    reject(event);
+                });
+            });
+        });
+    }
 }
 exports.StreamSocket = StreamSocket;
+function isError(response) {
+    return response.error != null;
+}
+function isWarning(response) {
+    return response.warning != null;
+}

package/dist/wrapper/base64Encode.d.ts

@@ -0,0 +1 @@
+export declare function base64Encode(str: string): string;

package/dist/wrapper/base64Encode.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Encode = void 0;
+function base64Encode(str) {
+    if (typeof Buffer === "function") {
+        // Node.js environment
+        return Buffer.from(str).toString("base64");
+    }
+    else if (typeof btoa === "function") {
+        // Browser environment
+        return btoa(str);
+    }
+    else {
+        throw new Error("Base64 encoding not supported in this environment.");
+    }
+}
+exports.base64Encode = base64Encode;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hume",
-    "version": "0.3.2",
+    "version": "0.4.0",
     "private": false,
     "repository": "https://github.com/HumeAI/hume-typescript-sdk",
     "main": "./index.js",
@@ -17,7 +17,8 @@
         "qs": "6.11.2",
         "ws": "^8.14.2",
         "@types/ws": "^8.5.9",
-        "uuid": "9.0.1"
+        "uuid": "9.0.1",
+        "@types/uuid": "9.0.7"
     },
     "devDependencies": {
         "@types/url-join": "4.0.1",

package/wrapper/HumeStreamingClient.d.ts

@@ -1,23 +1,28 @@
 import * as Hume from "../api";
-import * as core from "../core";
 import { StreamSocket } from "./StreamSocket";
+import WebSocket from "ws";
 export declare namespace HumeStreamingClient {
     interface Options {
-        apiKey: core.Supplier<string>;
+        apiKey: string;
         openTimeoutInSeconds?: number;
     }
     interface ConnectArgs {
         config: Hume.ModelConfig;
         streamWindowMs?: number;
-        onOpen?: () => void;
+        onOpen?: (event: WebSocket.Event) => void;
         onMessage?: (message: Hume.ModelResponse) => void;
         onWarning?: (error: Hume.ModelsWarning) => void;
         onError?: (error: Hume.ModelsError) => void;
-        onClose?: () => void;
+        onClose?: (event: WebSocket.Event) => void;
     }
 }
 export declare class HumeStreamingClient {
     protected readonly _options: HumeStreamingClient.Options;
     constructor(_options: HumeStreamingClient.Options);
-    connect(args: HumeStreamingClient.ConnectArgs): Promise<StreamSocket>;
+    connect(args: HumeStreamingClient.ConnectArgs): StreamSocket;
 }
+export declare function parse(data: WebSocket.Data, args?: {
+    onMessage?: (message: Hume.ModelResponse) => void;
+    onWarning?: (error: Hume.ModelsWarning) => void;
+    onError?: (error: Hume.ModelsError) => void;
+}): Promise<Hume.ModelResponse | Hume.ModelsWarning | Hume.ModelsError | undefined>;

package/wrapper/HumeStreamingClient.js

@@ -35,8 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HumeStreamingClient = void 0;
-const core = __importStar(require("../core"));
+exports.parse = exports.HumeStreamingClient = void 0;
 const serializers = __importStar(require("../serialization"));
 const StreamSocket_1 = require("./StreamSocket");
 const ws_1 = __importDefault(require("ws"));
@@ -45,81 +44,76 @@ class HumeStreamingClient {
         this._options = _options;
     }
     connect(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const websocket = new ws_1.default(`wss://api.hume.ai/v0/stream/models`, {
-                headers: {
-                    "X-Hume-Api-Key": yield core.Supplier.get(this._options.apiKey),
-                },
-                timeout: this._options.openTimeoutInSeconds,
-            });
-            websocket.addEventListener("open", () => {
-                var _a;
-                (_a = args.onOpen) === null || _a === void 0 ? void 0 : _a.call(args);
-            });
-            websocket.addEventListener("error", (e) => {
-                var _a;
-                (_a = args.onError) === null || _a === void 0 ? void 0 : _a.call(args, {
-                    code: e.type,
-                    error: e.message,
-                });
-            });
-            websocket.addEventListener("message", ({ data }) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
-                const body = JSON.parse(data);
-                const parsedResponse = yield serializers.ModelResponse.parse(body, {
-                    unrecognizedObjectKeys: "passthrough",
-                    allowUnrecognizedUnionMembers: true,
-                    allowUnrecognizedEnumValues: true,
-                    breadcrumbsPrefix: ["response"],
-                });
-                if (parsedResponse.ok) {
-                    (_a = args.onMessage) === null || _a === void 0 ? void 0 : _a.call(args, parsedResponse.value);
-                    return;
-                }
-                const parsedWarning = yield serializers.ModelsWarning.parse(body, {
-                    unrecognizedObjectKeys: "passthrough",
-                    allowUnrecognizedUnionMembers: true,
-                    allowUnrecognizedEnumValues: true,
-                    breadcrumbsPrefix: ["response"],
-                });
-                if (parsedWarning.ok) {
-                    (_b = args.onWarning) === null || _b === void 0 ? void 0 : _b.call(args, parsedWarning.value);
-                    return;
-                }
-                const parsedError = yield serializers.ModelsError.parse(body, {
-                    unrecognizedObjectKeys: "passthrough",
-                    allowUnrecognizedUnionMembers: true,
-                    allowUnrecognizedEnumValues: true,
-                    breadcrumbsPrefix: ["response"],
-                });
-                if (parsedError.ok) {
-                    (_c = args.onError) === null || _c === void 0 ? void 0 : _c.call(args, parsedError.value);
-                    return;
-                }
-            }));
-            websocket.addEventListener("close", () => {
-                var _a;
-                (_a = args.onClose) === null || _a === void 0 ? void 0 : _a.call(args);
+        const websocket = new ws_1.default(`wss://api.hume.ai/v0/stream/models`, {
+            headers: {
+                "X-Hume-Api-Key": this._options.apiKey,
+            },
+            timeout: this._options.openTimeoutInSeconds,
+        });
+        websocket.addEventListener("open", (event) => {
+            var _a;
+            (_a = args.onOpen) === null || _a === void 0 ? void 0 : _a.call(args, event);
+        });
+        websocket.addEventListener("error", (e) => {
+            var _a;
+            (_a = args.onError) === null || _a === void 0 ? void 0 : _a.call(args, {
+                code: e.type,
+                error: e.message,
             });
-            return new Promise((resolve) => {
-                if (websocket && websocket.readyState !== websocket.OPEN) {
-                    websocket.addEventListener("open", () => {
-                        resolve(new StreamSocket_1.StreamSocket({
-                            websocket,
-                            streamWindowMs: args.streamWindowMs,
-                            config: args.config,
-                        }));
-                    });
-                }
-                else {
-                    resolve(new StreamSocket_1.StreamSocket({
-                        websocket,
-                        streamWindowMs: args.streamWindowMs,
-                        config: args.config,
-                    }));
-                }
+        });
+        websocket.addEventListener("message", ({ data }) => __awaiter(this, void 0, void 0, function* () {
+            parse(data, {
+                onMessage: args.onMessage,
+                onWarning: args.onWarning,
+                onError: args.onError,
             });
+        }));
+        websocket.addEventListener("close", (event) => {
+            var _a;
+            (_a = args.onClose) === null || _a === void 0 ? void 0 : _a.call(args, event);
+        });
+        return new StreamSocket_1.StreamSocket({
+            websocket,
+            streamWindowMs: args.streamWindowMs,
+            config: args.config,
         });
     }
 }
 exports.HumeStreamingClient = HumeStreamingClient;
+function parse(data, args = {}) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const message = JSON.parse(data);
+        const parsedResponse = yield serializers.ModelResponse.parse(message, {
+            unrecognizedObjectKeys: "passthrough",
+            allowUnrecognizedUnionMembers: true,
+            allowUnrecognizedEnumValues: true,
+            breadcrumbsPrefix: ["response"],
+        });
+        if (parsedResponse.ok) {
+            (_a = args.onMessage) === null || _a === void 0 ? void 0 : _a.call(args, parsedResponse.value);
+            return parsedResponse.value;
+        }
+        const parsedWarning = yield serializers.ModelsWarning.parse(message, {
+            unrecognizedObjectKeys: "passthrough",
+            allowUnrecognizedUnionMembers: true,
+            allowUnrecognizedEnumValues: true,
+            breadcrumbsPrefix: ["response"],
+        });
+        if (parsedWarning.ok) {
+            (_b = args.onWarning) === null || _b === void 0 ? void 0 : _b.call(args, parsedWarning.value);
+            return parsedWarning.value;
+        }
+        const parsedError = yield serializers.ModelsError.parse(message, {
+            unrecognizedObjectKeys: "passthrough",
+            allowUnrecognizedUnionMembers: true,
+            allowUnrecognizedEnumValues: true,
+            breadcrumbsPrefix: ["response"],
+        });
+        if (parsedError.ok) {
+            (_c = args.onError) === null || _c === void 0 ? void 0 : _c.call(args, parsedError.value);
+            return parsedError.value;
+        }
+    });
+}
+exports.parse = parse;

package/wrapper/StreamSocket.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import WebSocket from "ws";
 import * as Hume from "../api";
+import * as fs from "fs";
 export declare namespace StreamSocket {
     interface Args {
         websocket: WebSocket;
@@ -14,29 +15,16 @@ export declare class StreamSocket {
     private config;
     constructor({ websocket, config, streamWindowMs }: StreamSocket.Args);
     /**
-     * Send a file on the `StreamSocket`
+     * Send file on the `StreamSocket`
      *
-     * @param filepath Path to media file to send on socket connection
-     * @param config List of model configurations.
-     * If set these configurations will overwrite any configurations
-     * set when initializing the `StreamSocket`
-     */
-    sendFile({ filepath, config, }: {
-        filepath: string;
-        config?: Hume.ModelConfig;
-    }): Promise<void>;
-    /**
-     * Send raw bytes on the `StreamSocket`
-     *
-     * @param buffer Raw bytes of media to send on socket connection
-     * @param config List of model configurations.
-     * If set these configurations will overwrite any configurations
-     * set when initializing the `StreamSocket`
+     * @param file A fs.ReadStream | File | Blob
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
      */
-    sendBuffer({ buffer, config, }: {
-        buffer: Buffer;
+    sendFile({ file, config, }: {
+        file: fs.ReadStream | Blob;
         config?: Hume.ModelConfig;
-    }): void;
+    }): Promise<Hume.ModelResponse>;
     /**
      * Send text on the `StreamSocket`
      *
@@ -44,10 +32,10 @@ export declare class StreamSocket {
      * @param config This method is intended for use with a `LanguageConfig`.
      * When the socket is configured for other modalities this method will fail.
      */
-    sendText({ text, config, }: {
+    sendText({ text, config }: {
         text: string;
         config?: Hume.ModelConfig;
-    }): void;
+    }): Promise<Hume.ModelResponse>;
     /**
      * Send facemesh landmarks on the `StreamSocket`
      *
@@ -61,7 +49,7 @@ export declare class StreamSocket {
     sendFacemesh({ landmarks, config, }: {
         landmarks: number[][][];
         config?: Hume.ModelConfig;
-    }): void;
+    }): Promise<Hume.ModelResponse>;
     /**
      *
      * Reset the streaming sliding window.
@@ -69,15 +57,17 @@ export declare class StreamSocket {
      * Call this method when some media has been fully processed and you want to continue using the same
      * streaming connection without leaking context across media samples.
      */
-    reset(): void;
+    reset(): Promise<void>;
     /**
      *
      * Get details associated with the current streaming connection.
      *
      */
-    getJobDetails(): void;
+    getJobDetails(): Promise<void>;
     /**
      * Closes the underlying socket.
      */
     close(): void;
+    private send;
+    private tillSocketOpen;
 }