@picovoice/eagle-web 0.1.1 → 0.2.0

package/src/eagle_errors.ts

@@ -0,0 +1,252 @@
+//
+// Copyright 2023 Picovoice Inc.
+//
+// You may not use this file except in compliance with the license. A copy of the license is located in the "LICENSE"
+// file accompanying this source.
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+//
+
+import { PvError } from '@picovoice/web-utils';
+import { PvStatus } from './types';
+
+class EagleError extends Error {
+  private readonly _status: PvStatus;
+  private readonly _shortMessage: string;
+  private readonly _messageStack: string[];
+
+  constructor(
+    status: PvStatus,
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(EagleError.errorToString(message, messageStack, pvError));
+    this._status = status;
+    this.name = 'EagleError';
+    this._shortMessage = message;
+    this._messageStack = messageStack;
+  }
+
+  get status(): PvStatus {
+    return this._status;
+  }
+
+  get shortMessage(): string {
+    return this._shortMessage;
+  }
+
+  get messageStack(): string[] {
+    return this._messageStack;
+  }
+
+  private static errorToString(
+    initial: string,
+    messageStack: string[],
+    pvError: PvError | null = null
+  ): string {
+    let msg = initial;
+
+    if (pvError) {
+      const pvErrorMessage = pvError.getErrorString();
+      if (pvErrorMessage.length > 0) {
+        msg += `\nDetails: ${pvErrorMessage}`;
+      }
+    }
+
+    if (messageStack.length > 0) {
+      msg += `: ${messageStack.reduce(
+        (acc, value, index) => acc + '\n  [' + index + '] ' + value,
+        ''
+      )}`;
+    }
+
+    return msg;
+  }
+}
+
+class EagleOutOfMemoryError extends EagleError {
+  constructor(
+    message: string,
+    messageStack?: string[],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.OUT_OF_MEMORY, message, messageStack, pvError);
+    this.name = 'EagleOutOfMemoryError';
+  }
+}
+
+class EagleIOError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.IO_ERROR, message, messageStack, pvError);
+    this.name = 'EagleIOError';
+  }
+}
+
+class EagleInvalidArgumentError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.INVALID_ARGUMENT, message, messageStack, pvError);
+    this.name = 'EagleInvalidArgumentError';
+  }
+}
+
+class EagleStopIterationError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.STOP_ITERATION, message, messageStack, pvError);
+    this.name = 'EagleStopIterationError';
+  }
+}
+
+class EagleKeyError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.KEY_ERROR, message, messageStack, pvError);
+    this.name = 'EagleKeyError';
+  }
+}
+
+class EagleInvalidStateError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.INVALID_STATE, message, messageStack, pvError);
+    this.name = 'EagleInvalidStateError';
+  }
+}
+
+class EagleRuntimeError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.RUNTIME_ERROR, message, messageStack, pvError);
+    this.name = 'EagleRuntimeError';
+  }
+}
+
+class EagleActivationError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.ACTIVATION_ERROR, message, messageStack, pvError);
+    this.name = 'EagleActivationError';
+  }
+}
+
+class EagleActivationLimitReachedError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.ACTIVATION_LIMIT_REACHED, message, messageStack, pvError);
+    this.name = 'EagleActivationLimitReachedError';
+  }
+}
+
+class EagleActivationThrottledError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.ACTIVATION_THROTTLED, message, messageStack, pvError);
+    this.name = 'EagleActivationThrottledError';
+  }
+}
+
+class EagleActivationRefusedError extends EagleError {
+  constructor(
+    message: string,
+    messageStack: string[] = [],
+    pvError: PvError | null = null
+  ) {
+    super(PvStatus.ACTIVATION_REFUSED, message, messageStack, pvError);
+    this.name = 'EagleActivationRefusedError';
+  }
+}
+
+export {
+  EagleError,
+  EagleOutOfMemoryError,
+  EagleIOError,
+  EagleInvalidArgumentError,
+  EagleStopIterationError,
+  EagleKeyError,
+  EagleInvalidStateError,
+  EagleRuntimeError,
+  EagleActivationError,
+  EagleActivationLimitReachedError,
+  EagleActivationThrottledError,
+  EagleActivationRefusedError,
+};
+
+export function pvStatusToException(
+  pvStatus: PvStatus,
+  errorMessage: string,
+  messageStack: string[] = [],
+  pvError: PvError | null = null
+): EagleError {
+  switch (pvStatus) {
+    case PvStatus.OUT_OF_MEMORY:
+      return new EagleOutOfMemoryError(errorMessage, messageStack, pvError);
+    case PvStatus.IO_ERROR:
+      return new EagleIOError(errorMessage, messageStack, pvError);
+    case PvStatus.INVALID_ARGUMENT:
+      return new EagleInvalidArgumentError(errorMessage, messageStack, pvError);
+    case PvStatus.STOP_ITERATION:
+      return new EagleStopIterationError(errorMessage, messageStack, pvError);
+    case PvStatus.KEY_ERROR:
+      return new EagleKeyError(errorMessage, messageStack, pvError);
+    case PvStatus.INVALID_STATE:
+      return new EagleInvalidStateError(errorMessage, messageStack, pvError);
+    case PvStatus.RUNTIME_ERROR:
+      return new EagleRuntimeError(errorMessage, messageStack, pvError);
+    case PvStatus.ACTIVATION_ERROR:
+      return new EagleActivationError(errorMessage, messageStack, pvError);
+    case PvStatus.ACTIVATION_LIMIT_REACHED:
+      return new EagleActivationLimitReachedError(
+        errorMessage,
+        messageStack,
+        pvError
+      );
+    case PvStatus.ACTIVATION_THROTTLED:
+      return new EagleActivationThrottledError(
+        errorMessage,
+        messageStack,
+        pvError
+      );
+    case PvStatus.ACTIVATION_REFUSED:
+      return new EagleActivationRefusedError(
+        errorMessage,
+        messageStack,
+        pvError
+      );
+    default:
+      // eslint-disable-next-line no-console
+      console.warn(`Unmapped error code: ${pvStatus}`);
+      return new EagleError(pvStatus, errorMessage);
+  }
+}

package/src/eagle_profiler_worker.ts

@@ -22,6 +22,7 @@ import {
   EagleProfilerWorkerResetResponse,
 } from './types';
 import { loadModel } from '@picovoice/web-utils';
+import { pvStatusToException } from "./eagle_errors";
 
 export class EagleProfilerWorker {
   private readonly _worker: Worker;
@@ -31,6 +32,7 @@ export class EagleProfilerWorker {
 
   private static _wasm: string;
   private static _wasmSimd: string;
+  private static _sdk: string = "web";
 
   private constructor(
     worker: Worker,
@@ -85,6 +87,10 @@ export class EagleProfilerWorker {
     }
   }
 
+  public static setSdk(sdk: string): void {
+    EagleProfilerWorker._sdk = sdk;
+  }
+
   /**
    * Creates an instance of profiler component of the Eagle Speaker Recognition Engine.
    *
@@ -129,11 +135,11 @@ export class EagleProfilerWorker {
               break;
             case 'failed':
             case 'error':
-              reject(event.data.message);
+              reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
               break;
             default:
               // @ts-ignore
-              reject(`Unrecognized command: ${event.data.command}`);
+              reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
           }
         };
       }
@@ -145,6 +151,7 @@ export class EagleProfilerWorker {
       modelPath: modelPath,
       wasm: this._wasm,
       wasmSimd: this._wasmSimd,
+      sdk: this._sdk,
     });
 
     return returnPromise;
@@ -187,11 +194,11 @@ export class EagleProfilerWorker {
               break;
             case 'failed':
             case 'error':
-              reject(event.data.message);
+              reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
               break;
             default:
               // @ts-ignore
-              reject(`Unrecognized command: ${event.data.command}`);
+              reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
           }
         };
       }
@@ -223,11 +230,11 @@ export class EagleProfilerWorker {
               break;
             case 'failed':
             case 'error':
-              reject(event.data.message);
+              reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
               break;
             default:
               // @ts-ignore
-              reject(`Unrecognized command: ${event.data.command}`);
+              reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
           }
         };
       }
@@ -254,11 +261,11 @@ export class EagleProfilerWorker {
             break;
           case 'failed':
           case 'error':
-            reject(event.data.message);
+            reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
             break;
           default:
             // @ts-ignore
-            reject(`Unrecognized command: ${event.data.command}`);
+            reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
         }
       };
     });
@@ -283,11 +290,11 @@ export class EagleProfilerWorker {
             break;
           case 'failed':
           case 'error':
-            reject(event.data.message);
+            reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
             break;
           default:
             // @ts-ignore
-            reject(`Unrecognized command: ${event.data.command}`);
+            reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
         }
       };
     });

package/src/eagle_profiler_worker_handler.ts

@@ -15,7 +15,9 @@ import {
   EagleProfilerWorkerEnrollRequest,
   EagleProfilerWorkerInitRequest,
   EagleProfilerWorkerRequest,
+  PvStatus,
 } from './types';
+import { EagleError } from "./eagle_errors";
 
 let profiler: EagleProfiler | null = null;
 
@@ -25,12 +27,14 @@ const initRequest = async (
   if (profiler !== null) {
     return {
       command: 'error',
-      message: 'Eagle profiler already initialized',
+      status: PvStatus.INVALID_STATE,
+      shortMessage: 'Eagle profiler already initialized',
     };
   }
   try {
     EagleProfiler.setWasm(request.wasm);
     EagleProfiler.setWasmSimd(request.wasmSimd);
+    EagleProfiler.setSdk(request.sdk);
     profiler = await EagleProfiler._init(request.accessKey, request.modelPath);
     return {
       command: 'ok',
@@ -39,10 +43,20 @@ const initRequest = async (
       version: profiler.version,
     };
   } catch (e: any) {
-    return {
-      command: 'error',
-      message: e.message,
-    };
+    if (e instanceof EagleError) {
+      return {
+        command: 'error',
+        status: e.status,
+        shortMessage: e.shortMessage,
+        messageStack: e.messageStack
+      };
+    } else {
+      return {
+        command: 'error',
+        status: PvStatus.RUNTIME_ERROR,
+        shortMessage: e.message
+      };
+    }
   }
 };
 
@@ -52,7 +66,8 @@ const enrollRequest = async (
   if (profiler === null) {
     return {
       command: 'error',
-      message: 'Eagle profiler not initialized',
+      status: PvStatus.INVALID_STATE,
+      shortMessage: 'Eagle profiler not initialized',
     };
   }
   try {
@@ -62,10 +77,20 @@ const enrollRequest = async (
       result,
     };
   } catch (e: any) {
-    return {
-      command: 'error',
-      message: e.message,
-    };
+    if (e instanceof EagleError) {
+      return {
+        command: 'error',
+        status: e.status,
+        shortMessage: e.shortMessage,
+        messageStack: e.messageStack
+      };
+    } else {
+      return {
+        command: 'error',
+        status: PvStatus.RUNTIME_ERROR,
+        shortMessage: e.message
+      };
+    }
   }
 };
 
@@ -73,7 +98,8 @@ const exportRequest = async (): Promise<any> => {
   if (profiler === null) {
     return {
       command: 'error',
-      message: 'Eagle profiler not initialized',
+      status: PvStatus.INVALID_STATE,
+      shortMessage: 'Eagle profiler not initialized',
     };
   }
   try {
@@ -83,10 +109,20 @@ const exportRequest = async (): Promise<any> => {
       profile,
     };
   } catch (e: any) {
-    return {
-      command: 'error',
-      message: e.message,
-    };
+    if (e instanceof EagleError) {
+      return {
+        command: 'error',
+        status: e.status,
+        shortMessage: e.shortMessage,
+        messageStack: e.messageStack
+      };
+    } else {
+      return {
+        command: 'error',
+        status: PvStatus.RUNTIME_ERROR,
+        shortMessage: e.message
+      };
+    }
   }
 };
 
@@ -94,7 +130,8 @@ const resetRequest = async (): Promise<any> => {
   if (profiler === null) {
     return {
       command: 'error',
-      message: 'Eagle not initialized',
+      status: PvStatus.INVALID_STATE,
+      shortMessage: 'Eagle profiler not initialized',
     };
   }
   try {
@@ -103,10 +140,20 @@ const resetRequest = async (): Promise<any> => {
       command: 'ok',
     };
   } catch (e: any) {
-    return {
-      command: 'error',
-      message: e.message,
-    };
+    if (e instanceof EagleError) {
+      return {
+        command: 'error',
+        status: e.status,
+        shortMessage: e.shortMessage,
+        messageStack: e.messageStack
+      };
+    } else {
+      return {
+        command: 'error',
+        status: PvStatus.RUNTIME_ERROR,
+        shortMessage: e.message
+      };
+    }
   }
 };
 

package/src/eagle_worker.ts

@@ -20,6 +20,7 @@ import {
   EagleProfile,
 } from './types';
 import { loadModel } from '@picovoice/web-utils';
+import { pvStatusToException } from "./eagle_errors";
 
 export class EagleWorker {
   private readonly _worker: Worker;
@@ -29,6 +30,7 @@ export class EagleWorker {
 
   private static _wasm: string;
   private static _wasmSimd: string;
+  private static _sdk: string = "web";
 
   private constructor(
     worker: Worker,
@@ -83,10 +85,14 @@ export class EagleWorker {
     }
   }
 
+  public static setSdk(sdk: string): void {
+    EagleWorker._sdk = sdk;
+  }
+
   /**
    * Creates an instance of the Picovoice Eagle Speaker Recognition Engine.
    *
-   * @param accessKey: AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
+   * @param accessKey AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
    * @param model Eagle model options.
    * @param model.base64 The model in base64 string to initialize Eagle.
    * @param model.publicPath The model path relative to the public directory.
@@ -129,11 +135,11 @@ export class EagleWorker {
               break;
             case 'failed':
             case 'error':
-              reject(event.data.message);
+              reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
               break;
             default:
               // @ts-ignore
-              reject(`Unrecognized command: ${event.data.command}`);
+              reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
           }
         };
       }
@@ -148,6 +154,7 @@ export class EagleWorker {
         : speakerProfiles,
       wasm: this._wasm,
       wasmSimd: this._wasmSimd,
+      sdk: this._sdk,
     });
 
     return returnPromise;
@@ -174,11 +181,11 @@ export class EagleWorker {
             break;
           case 'failed':
           case 'error':
-            reject(event.data.message);
+            reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
             break;
           default:
             // @ts-ignore
-            reject(`Unrecognized command: ${event.data.command}`);
+            reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
         }
       };
     });
@@ -206,11 +213,11 @@ export class EagleWorker {
             break;
           case 'failed':
           case 'error':
-            reject(event.data.message);
+            reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
             break;
           default:
             // @ts-ignore
-            reject(`Unrecognized command: ${event.data.command}`);
+            reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
         }
       };
     });
@@ -235,11 +242,11 @@ export class EagleWorker {
             break;
           case 'failed':
           case 'error':
-            reject(event.data.message);
+            reject(pvStatusToException(event.data.status, event.data.shortMessage, event.data.messageStack));
             break;
           default:
             // @ts-ignore
-            reject(`Unrecognized command: ${event.data.command}`);
+            reject(pvStatusToException(PvStatus.RUNTIME_ERROR, `Unrecognized command: ${event.data.command}`));
         }
       };
     });