hume 0.8.1 → 0.8.4

package/wrapper/expressionMeasurement/ExpressionMeasurementClient.d.ts

@@ -1,6 +1,6 @@
-import { ExpressionMeasurement as FernClient } from "../../api/resources/expressionMeasurement/client/Client";
-import { BatchClient } from "./batch/BatchClient";
-import { StreamClient } from "./streaming/StreamingClient";
+import { ExpressionMeasurement as FernClient } from '../../api/resources/expressionMeasurement/client/Client';
+import { BatchClient } from './batch/BatchClient';
+import { StreamClient } from './streaming/StreamingClient';
 export declare class ExpressionMeasurement extends FernClient {
     protected _batch: BatchClient | undefined;
     get batch(): BatchClient;

package/wrapper/expressionMeasurement/batch/BatchClient.d.ts

@@ -1,6 +1,6 @@
-import { Batch as FernClient } from "../../../api/resources/expressionMeasurement/resources/batch/client/Client";
-import * as Hume from "../../../api";
-import { Job } from "./Job";
+import { Batch as FernClient } from '../../../api/resources/expressionMeasurement/resources/batch/client/Client';
+import * as Hume from '../../../api';
+import { Job } from './Job';
 export declare class BatchClient extends FernClient {
     startInferenceJob(request?: Hume.expressionMeasurement.InferenceBaseRequest, requestOptions?: FernClient.RequestOptions): Promise<Job>;
 }

package/wrapper/expressionMeasurement/batch/Job.d.ts

@@ -1,5 +1,5 @@
-import * as Hume from "../../../api";
-import { BatchClient } from "./BatchClient";
+import * as Hume from '../../../api';
+import { BatchClient } from './BatchClient';
 export declare class Job implements Hume.expressionMeasurement.JobId {
     readonly jobId: string;
     private readonly client;

package/wrapper/expressionMeasurement/batch/Job.js

@@ -70,7 +70,8 @@ class JobCompletionPoller {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const jobDetails = yield this.client.getJobDetails(this.jobId);
-                if (jobDetails.state.status === "COMPLETED" || jobDetails.state.status === "FAILED") {
+                if (jobDetails.state.status === 'COMPLETED' ||
+                    jobDetails.state.status === 'FAILED') {
                     onTerminal();
                     this.stop();
                 }

package/wrapper/expressionMeasurement/streaming/StreamSocket.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import WebSocket from "ws";
-import * as Hume from "../../../api";
-import * as fs from "fs";
+import WebSocket from 'ws';
+import * as Hume from '../../../api';
+import * as fs from 'fs';
 export declare namespace StreamSocket {
     interface Args {
         websocket: WebSocket;

package/wrapper/expressionMeasurement/streaming/StreamSocket.js

@@ -70,7 +70,7 @@ class StreamSocket {
             if (config != null) {
                 this.config = config;
             }
-            let contents = "";
+            let contents = '';
             if (file instanceof fs.ReadStream) {
                 const chunks = [];
                 try {
@@ -86,10 +86,10 @@ class StreamSocket {
                     }
                     finally { if (e_1) throw e_1.error; }
                 }
-                contents = Buffer.concat(chunks).toString("base64");
+                contents = Buffer.concat(chunks).toString('base64');
             }
             else if (file instanceof Blob) {
-                const toBase64 = (file) => new Promise((res, err) => {
+                const toBase64 = (file) => new Promise((res) => {
                     const reader = new FileReader();
                     reader.readAsDataURL(file);
                     reader.onload = () => res(reader.result);
@@ -97,7 +97,9 @@ class StreamSocket {
                 contents = yield toBase64(file);
             }
             else {
-                throw new errors.HumeError({ message: `file must be one of ReadStream or Blob.` });
+                throw new errors.HumeError({
+                    message: `file must be one of ReadStream or Blob.`,
+                });
             }
             const request = {
                 payloadId: (0, uuid_1.v4)(),
@@ -110,7 +112,9 @@ class StreamSocket {
             }
             const response = yield this.send(request);
             if (response == null) {
-                throw new errors.HumeError({ message: `Received no response after sending file: ${file}` });
+                throw new errors.HumeError({
+                    message: `Received no response after sending file: ${file}`,
+                });
             }
             return response;
         });
@@ -138,7 +142,9 @@ class StreamSocket {
             }
             const response = yield this.send(request);
             if (response == null) {
-                throw new errors.HumeError({ message: `Received no response after sending text: ${text}` });
+                throw new errors.HumeError({
+                    message: `Received no response after sending text: ${text}`,
+                });
             }
             return response;
         });
@@ -198,17 +204,19 @@ class StreamSocket {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.tillSocketOpen();
             const jsonPayload = yield serializers.expressionMeasurement.StreamData.jsonOrThrow(payload, {
-                unrecognizedObjectKeys: "strip",
+                unrecognizedObjectKeys: 'strip',
             });
             this.websocket.send(JSON.stringify(jsonPayload));
-            const response = yield new Promise((resolve, reject) => {
-                this.websocket.addEventListener("message", (event) => {
+            const response = yield new Promise((resolve) => {
+                this.websocket.addEventListener('message', (event) => {
                     const response = (0, StreamingClient_1.parse)(event.data);
                     resolve(response);
                 });
             });
             if (response != null && isError(response)) {
-                throw new errors.HumeError({ message: `CODE ${response.code}: ${response.error}` });
+                throw new errors.HumeError({
+                    message: `CODE ${response.code}: ${response.error}`,
+                });
             }
             return response;
         });
@@ -219,10 +227,10 @@ class StreamSocket {
                 return this.websocket;
             }
             return new Promise((resolve, reject) => {
-                this.websocket.addEventListener("open", () => {
+                this.websocket.addEventListener('open', () => {
                     resolve(this.websocket);
                 });
-                this.websocket.addEventListener("error", (event) => {
+                this.websocket.addEventListener('error', (event) => {
                     reject(event);
                 });
             });

package/wrapper/expressionMeasurement/streaming/StreamingClient.d.ts

@@ -1,7 +1,7 @@
-import * as Hume from "../../../api";
-import * as core from "../../../core";
-import { StreamSocket } from "./StreamSocket";
-import WebSocket from "ws";
+import * as Hume from '../../../api';
+import * as core from '../../../core';
+import { StreamSocket } from './StreamSocket';
+import WebSocket from 'ws';
 export declare namespace StreamClient {
     interface Options {
         apiKey?: core.Supplier<string | undefined>;

package/wrapper/expressionMeasurement/streaming/StreamingClient.js

@@ -46,28 +46,28 @@ class StreamClient {
     connect(args) {
         const websocket = new ws_1.default(`wss://api.hume.ai/v0/stream/models`, {
             headers: {
-                "X-Hume-Api-Key": typeof this._options.apiKey === "string" ? this._options.apiKey : "",
+                'X-Hume-Api-Key': typeof this._options.apiKey === 'string' ? this._options.apiKey : '',
             },
             timeout: 10,
         });
-        websocket.addEventListener("open", (event) => {
+        websocket.addEventListener('open', (event) => {
             var _a;
             (_a = args.onOpen) === null || _a === void 0 ? void 0 : _a.call(args, event);
         });
-        websocket.addEventListener("error", (e) => {
+        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* () {
+        websocket.addEventListener('message', ({ data }) => __awaiter(this, void 0, void 0, function* () {
             parse(data, {
                 onMessage: args.onMessage,
                 onError: args.onError,
             });
         }));
-        websocket.addEventListener("close", (event) => {
+        websocket.addEventListener('close', (event) => {
             var _a;
             (_a = args.onClose) === null || _a === void 0 ? void 0 : _a.call(args, event);
         });
@@ -84,20 +84,20 @@ function parse(data, args = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = JSON.parse(data);
         const parsedResponse = yield serializers.expressionMeasurement.stream.StreamBurst.parse(message, {
-            unrecognizedObjectKeys: "passthrough",
+            unrecognizedObjectKeys: 'passthrough',
             allowUnrecognizedUnionMembers: true,
             allowUnrecognizedEnumValues: true,
-            breadcrumbsPrefix: ["response"],
+            breadcrumbsPrefix: ['response'],
         });
         if (parsedResponse.ok) {
             (_a = args.onMessage) === null || _a === void 0 ? void 0 : _a.call(args, parsedResponse.value);
             return parsedResponse.value;
         }
         const parsedError = yield serializers.expressionMeasurement.stream.StreamError.parse(message, {
-            unrecognizedObjectKeys: "passthrough",
+            unrecognizedObjectKeys: 'passthrough',
             allowUnrecognizedUnionMembers: true,
             allowUnrecognizedEnumValues: true,
-            breadcrumbsPrefix: ["response"],
+            breadcrumbsPrefix: ['response'],
         });
         if (parsedError.ok) {
             (_b = args.onError) === null || _b === void 0 ? void 0 : _b.call(args, parsedError.value);

package/wrapper/fetchAccessToken.d.ts

@@ -2,9 +2,8 @@
  * Fetches a new access token from the Hume API using the provided API key and Secret key.
  *
  * @param args - The arguments for the request.
- * @returns Promise that resolves to the new access token.
+ * @returns Promise that resolves to the new access token or null.
  * @throws If the base64 encoding fails.
- * @throws If the network request fails.
  * @example
  * ```typescript
  * async function getToken() {
@@ -12,12 +11,13 @@
  *     apiKey: 'test',
  *     secretKey: 'test',
  *   });
+ *
  *   console.log(accessToken); // Outputs the access token
  * }
  * ```
  */
-export declare const fetchAccessToken: (args: {
+export declare const fetchAccessToken: ({ apiKey, secretKey, host, }: {
     apiKey: string;
     secretKey: string;
-    host?: string;
-}) => Promise<string>;
+    host?: string | undefined;
+}) => Promise<string | null>;

package/wrapper/fetchAccessToken.js

@@ -11,13 +11,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchAccessToken = void 0;
 const base64Encode_1 = require("./base64Encode");
+const zod_1 = require("zod");
 /**
  * Fetches a new access token from the Hume API using the provided API key and Secret key.
  *
  * @param args - The arguments for the request.
- * @returns Promise that resolves to the new access token.
+ * @returns Promise that resolves to the new access token or null.
  * @throws If the base64 encoding fails.
- * @throws If the network request fails.
  * @example
  * ```typescript
  * async function getToken() {
@@ -25,15 +25,15 @@ const base64Encode_1 = require("./base64Encode");
  *     apiKey: 'test',
  *     secretKey: 'test',
  *   });
+ *
  *   console.log(accessToken); // Outputs the access token
  * }
  * ```
  */
-const fetchAccessToken = (args) => __awaiter(void 0, void 0, void 0, function* () {
-    const { apiKey, secretKey, host = 'api.hume.ai' } = args;
+const fetchAccessToken = ({ apiKey, secretKey, host = 'api.hume.ai', }) => __awaiter(void 0, void 0, void 0, function* () {
     const authString = `${apiKey}:${secretKey}`;
     const encoded = (0, base64Encode_1.base64Encode)(authString);
-    const res = yield fetch(`https://${host}/oauth2-cc/token`, {
+    const response = yield fetch(`https://${host}/oauth2-cc/token`, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/x-www-form-urlencoded',
@@ -43,9 +43,32 @@ const fetchAccessToken = (args) => __awaiter(void 0, void 0, void 0, function* (
             grant_type: 'client_credentials',
         }).toString(),
         cache: 'no-cache',
-    });
-    const data = (yield res.json());
-    const accessToken = String(data['access_token']);
-    return accessToken;
+    })
+        .then((res) => {
+        // if reading response as json fails, return empty object
+        // this can happen when request returns XML due to server error
+        return res
+            .json()
+            .then((d) => d)
+            .catch(() => ({}));
+    })
+        .then((data) => {
+        // extract access_token value from received object
+        return zod_1.z
+            .object({
+            access_token: zod_1.z.string(),
+        })
+            .transform((data) => {
+            return data.access_token;
+        })
+            .safeParse(data);
+    })
+        .catch(() => ({
+        success: false,
+    }));
+    if (!response.success) {
+        return null;
+    }
+    return response.data;
 });
 exports.fetchAccessToken = fetchAccessToken;

package/wrapper/getBrowserSupportedMimeType.js

@@ -16,7 +16,7 @@ var MimeType;
  * @returns {boolean} Returns `true` if the `MediaRecorder` API is supported, otherwise `false`.
  */
 function isMediaRecorderSupported() {
-    return typeof MediaRecorder !== "undefined";
+    return typeof MediaRecorder !== 'undefined';
 }
 /**
  * Finds and returns the first MIME type from the given array that is supported by the `MediaRecorder`.
@@ -39,7 +39,7 @@ function getBrowserSupportedMimeType() {
     if (!isMediaRecorderSupported()) {
         return {
             success: false,
-            error: new Error("MediaRecorder is not supported"),
+            error: new Error('MediaRecorder is not supported'),
         };
     }
     const COMPATIBLE_MIME_TYPES = [MimeType.WEBM, MimeType.MP4, MimeType.WAV];
@@ -49,7 +49,7 @@ function getBrowserSupportedMimeType() {
     if (!supportedMimeType) {
         return {
             success: false,
-            error: new Error("Browser does not support any compatible mime types"),
+            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.

package/wrapper/index.d.ts

@@ -1,10 +1,10 @@
-export { base64Decode } from "./base64Decode";
-export { base64Encode } from "./base64Encode";
-export { convertBase64ToBlob } from "./convertBase64ToBlob";
-export { convertBlobToBase64 } from "./convertBlobToBase64";
-export { ensureSingleValidAudioTrack } from "./ensureSingleValidAudioTrack";
-export { checkForAudioTracks } from "./checkForAudioTracks";
-export { fetchAccessToken } from "./fetchAccessToken";
-export { getAudioStream } from "./getAudioStream";
-export { MimeType, getBrowserSupportedMimeType } from "./getBrowserSupportedMimeType";
-export { HumeClient } from "./HumeClient";
+export { base64Decode } from './base64Decode';
+export { base64Encode } from './base64Encode';
+export { convertBase64ToBlob } from './convertBase64ToBlob';
+export { convertBlobToBase64 } from './convertBlobToBase64';
+export { ensureSingleValidAudioTrack } from './ensureSingleValidAudioTrack';
+export { checkForAudioTracks } from './checkForAudioTracks';
+export { fetchAccessToken } from './fetchAccessToken';
+export { getAudioStream } from './getAudioStream';
+export { MimeType, getBrowserSupportedMimeType, } from './getBrowserSupportedMimeType';
+export { HumeClient } from './HumeClient';

package/jest.config.js

@@ -1,5 +0,0 @@
-/** @type {import('jest').Config} */
-module.exports = {
-    preset: "ts-jest",
-    testEnvironment: "node",
-};