hypha-rpc 0.20.59 → 0.20.61

package/dist/hypha-rpc-websocket.js

@@ -23,8 +23,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   API_VERSION: () => (/* binding */ API_VERSION),
 /* harmony export */   RPC: () => (/* binding */ RPC)
 /* harmony export */ });
-/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils */ "./src/utils/index.js");
-/* harmony import */ var _utils_schema__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils/schema */ "./src/utils/schema.js");
+/* harmony import */ var _utils_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils/index.js */ "./src/utils/index.js");
+/* harmony import */ var _utils_schema_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils/schema.js */ "./src/utils/schema.js");
 /* harmony import */ var _msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @msgpack/msgpack */ "./node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs");
 /* harmony import */ var _msgpack_msgpack__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @msgpack/msgpack */ "./node_modules/@msgpack/msgpack/dist.es5+esm/encode.mjs");
 /**
@@ -123,7 +123,7 @@ function _annotate_service(service, serviceTypeInfo) {
           annotateRecursive(v, schemaInfo[k], newPath);
         } else if (typeof v === "function") {
           if (schemaInfo.hasOwnProperty(k)) {
-            newService[k] = (0,_utils_schema__WEBPACK_IMPORTED_MODULE_1__.schemaFunction)(v, {
+            newService[k] = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_1__.schemaFunction)(v, {
               name: schemaInfo[k]["name"],
               description: schemaInfo[k].description || "",
               parameters: schemaInfo[k]["parameters"],
@@ -145,7 +145,7 @@ function _annotate_service(service, serviceTypeInfo) {
           annotateRecursive(v, schemaInfo[i], newPath);
         } else if (typeof v === "function") {
           if (schemaInfo.hasOwnProperty(i)) {
-            newService[i] = (0,_utils_schema__WEBPACK_IMPORTED_MODULE_1__.schemaFunction)(v, {
+            newService[i] = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_1__.schemaFunction)(v, {
               name: schemaInfo[i]["name"],
               description: schemaInfo[i].description || "",
               parameters: schemaInfo[i]["parameters"],
@@ -280,7 +280,7 @@ class RemoteService extends Object {}
  * and receive messages from the opposite site (basically it
  * should only provide send() and onMessage() methods)
  */
-class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
+class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   constructor(
     connection,
     {
@@ -300,8 +300,8 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   ) {
     super(debug);
     this._codecs = codecs || {};
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(client_id && typeof client_id === "string");
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(client_id, "client_id is required");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(client_id && typeof client_id === "string");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(client_id, "client_id is required");
     this._client_id = client_id;
     this._name = name;
     this._app_id = app_id || "*";
@@ -344,8 +344,8 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       this.on("method", this._handle_method.bind(this));
       this.on("error", console.error);
 
-      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(connection.emit_message && connection.on_message);
-      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(connection.emit_message && connection.on_message);
+      (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
         connection.manager_id !== undefined,
         "Connection must have manager_id",
       );
@@ -428,7 +428,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
 
   async _ping(msg, context) {
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(msg == "ping");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(msg == "ping");
     return "pong";
   }
 
@@ -440,7 +440,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       _rpromise: true,
       _rdoc: "Ping a remote client",
     });
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)((await method("ping", timeout)) == "pong");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)((await method("ping", timeout)) == "pong");
   }
 
   _create_message(key, heartbeat, overwrite, context) {
@@ -473,7 +473,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     if (!cache[key]) {
       throw new Error(`Message with key ${key} does not exists.`);
     }
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(data instanceof ArrayBufferView);
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(data instanceof ArrayBufferView);
     cache[key].push(data);
   }
 
@@ -488,7 +488,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     if (!cache[key]) {
       throw new Error(`Message with key ${key} does not exists.`);
     }
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(data instanceof ArrayBufferView);
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(data instanceof ArrayBufferView);
     cache[key][index] = data;
   }
 
@@ -508,7 +508,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       this._object_store[key]["timer"].reset();
     }
     const cache = this._object_store["message_cache"];
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(!!context, "Context is required");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(!!context, "Context is required");
     if (!cache[key]) {
       throw new Error(`Message with key ${key} does not exists.`);
     }
@@ -566,8 +566,24 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     this._services = {};
   }
 
-  async disconnect() {
+  close() {
+    // Clear all heartbeat intervals
+    for (const session_id in this._object_store) {
+      if (this._object_store.hasOwnProperty(session_id)) {
+        const session = this._object_store[session_id];
+        if (session && session.heartbeat_task) {
+          clearInterval(session.heartbeat_task);
+        }
+        if (session && session.timer) {
+          session.timer.clear();
+        }
+      }
+    }
     this._fire("disconnected");
+  }
+
+  async disconnect() {
+    this.close();
     await this._connection.disconnect();
   }
 
@@ -614,9 +630,9 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     return this._services;
   }
   get_local_service(service_id, context) {
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(service_id);
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(service_id);
     const [ws, client_id] = context["to"].split("/");
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
       client_id === this._client_id,
       "Services can only be accessed locally",
     );
@@ -655,12 +671,12 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       service_id = service_id.split("@")[0];
       const app_id = service_uri.split("@")[1];
       if (this._app_id && this._app_id !== "*")
-        (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
           app_id === this._app_id,
           `Invalid app id: ${app_id} != ${this._app_id}`,
         );
     }
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(provider, `Invalid service uri: ${service_uri}`);
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(provider, `Invalid service uri: ${service_uri}`);
 
     try {
       const method = this._generate_remote_method({
@@ -670,19 +686,19 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         _rpromise: true,
         _rdoc: "Get a remote service",
       });
-      let svc = await (0,_utils__WEBPACK_IMPORTED_MODULE_0__.waitFor)(
+      let svc = await (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.waitFor)(
         method(service_id),
         timeout,
         "Timeout Error: Failed to get remote service: " + service_uri,
       );
       svc.id = `${provider}:${service_id}`;
       if (kwargs_expansion) {
-        svc = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.expandKwargs)(svc);
+        svc = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.expandKwargs)(svc);
       }
       if (case_conversion)
         return Object.assign(
           new RemoteService(),
-          (0,_utils__WEBPACK_IMPORTED_MODULE_0__.convertCase)(svc, case_conversion),
+          (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.convertCase)(svc, case_conversion),
         );
       else return Object.assign(new RemoteService(), svc);
     } catch (e) {
@@ -761,7 +777,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       api.id = api.id || "default";
       api = normApi;
     }
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
       api.id && typeof api.id === "string",
       `Service id not found: ${api}`,
     );
@@ -781,7 +797,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       require_context = api.config.require_context;
     if (api.config.run_in_executor) run_in_executor = true;
     const visibility = api.config.visibility || "protected";
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(["protected", "public"].includes(visibility));
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(["protected", "public"].includes(visibility));
     this._annotate_service_methods(
       api,
       api["id"],
@@ -870,7 +886,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     } else {
       service_id = service.id;
     }
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
       service_id && typeof service_id === "string",
       `Invalid service id: ${service_id}`,
     );
@@ -894,7 +910,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
 
   _ndarray(typedArray, shape, dtype) {
-    const _dtype = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(typedArray);
+    const _dtype = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(typedArray);
     if (dtype && dtype !== _dtype) {
       throw (
         "dtype doesn't match the type of the array: " + _dtype + " != " + dtype
@@ -937,12 +953,20 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           `Error in callback(${method_id}, ${description}): ${error}`,
         );
       } finally {
+        // Clear the timer first if it exists
         if (timer && timer.started) {
           timer.clear();
         }
+
+        // Clean up the entire session when resolve/reject is called
         if (clear_after_called && self._object_store[session_id]) {
-          // Simple cleanup - let the session manager handle the logic
-          self._cleanup_session_if_needed(session_id, name);
+          // For promise callbacks (resolve/reject), clean up the entire session
+          if (name === "resolve" || name === "reject") {
+            delete self._object_store[session_id];
+          } else {
+            // For other callbacks, just clean up this specific callback
+            self._cleanup_session_if_needed(session_id, name);
+          }
         }
       }
     };
@@ -952,31 +976,22 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
 
   // Clean session management - all logic in one place
   _cleanup_session_if_needed(session_id, callback_name) {
-    const store = this._get_session_store(session_id, false);
-    if (!store) return;
-
-    // Promise sessions: let the promise manager decide cleanup
-    if (store._promise_manager) {
-      if (store._promise_manager.should_cleanup_on_callback(callback_name)) {
-        store._promise_manager.settle();
-        delete this._object_store[session_id];
-      }
-      return;
+    // Python-style immediate cleanup - no complex logic needed
+    if (this._object_store[session_id]) {
+      delete this._object_store[session_id];
     }
-
-    // Regular sessions: cleanup immediately
-    delete this._object_store[session_id];
   }
 
   // Clean helper to identify promise method calls by session type
   _is_promise_method_call(method_path) {
     const session_id = method_path.split(".")[0];
-    const session = this._get_session_store(session_id, false);
-    return session && session._promise_manager;
+    // Simply check if session exists - no complex promise manager needed
+    return this._object_store[session_id] !== undefined;
   }
 
-  // Clean Promise Manager - encapsulates all promise lifecycle logic
+  // Simplified Promise Manager - no complex lifecycle needed
   _create_promise_manager() {
+    // Return minimal manager - Python doesn't need complex promise tracking
     return {
       settled: false,
       settle() {
@@ -986,6 +1001,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         return this.settled;
       },
       should_cleanup_on_callback(callback_name) {
+        // Always cleanup on resolve/reject like Python
         return callback_name === "resolve" || callback_name === "reject";
       },
     };
@@ -1009,9 +1025,8 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     }
     let encoded = {};
 
-    // Clean promise lifecycle management
-    store._promise_manager = this._create_promise_manager();
-
+    // Simplified promise lifecycle - no complex manager needed
+    // Just store the timer if needed
     if (timer && reject && this._method_timeout) {
       [encoded.heartbeat, store.heartbeat] = this._encode_callback(
         "heartbeat",
@@ -1025,11 +1040,12 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       encoded.interval = this._method_timeout / 2;
     }
 
+    // Always use immediate cleanup like Python
     [encoded.resolve, store.resolve] = this._encode_callback(
       "resolve",
       resolve,
       session_id,
-      clear_after_called,
+      true, // Always cleanup immediately
       timer,
       local_workspace,
       `resolve (${description})`,
@@ -1038,7 +1054,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       "reject",
       reject,
       session_id,
-      clear_after_called,
+      true, // Always cleanup immediately
       timer,
       local_workspace,
       `reject (${description})`,
@@ -1058,13 +1074,13 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     }
 
     const message_cache = remote_services.message_cache;
-    const message_id = session_id || (0,_utils__WEBPACK_IMPORTED_MODULE_0__.randId)();
+    const message_id = session_id || (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.randId)();
     const total_size = data.length;
     const start_time = Date.now(); // measure time
     const chunk_num = Math.ceil(total_size / this._long_message_chunk_size);
     if (remote_services.config.api_version >= 3) {
       await message_cache.create(message_id, !!session_id);
-      const semaphore = new _utils__WEBPACK_IMPORTED_MODULE_0__.Semaphore(CONCURRENCY_LIMIT);
+      const semaphore = new _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.Semaphore(CONCURRENCY_LIMIT);
 
       const tasks = [];
       for (let idx = 0; idx < chunk_num; idx++) {
@@ -1120,7 +1136,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
 
   emit(main_message, extra_data) {
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
       typeof main_message === "object" && main_message.type,
       "Invalid message, must be an object with a `type` fields.",
     );
@@ -1162,7 +1178,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
 
     function remote_method() {
       return new Promise(async (resolve, reject) => {
-        let local_session_id = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.randId)();
+        let local_session_id = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.randId)();
         if (local_parent) {
           // Store the children session under the parent
           local_session_id = local_parent + "." + local_session_id;
@@ -1353,7 +1369,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     let reject = null;
     let heartbeat_task = null;
     try {
-      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(data.method && data.ctx && data.from);
+      (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(data.method && data.ctx && data.from);
       const method_name = data.from + ":" + data.method;
       const remote_workspace = data.from.split("/")[0];
       const remote_client_id = data.from.split("/")[1];
@@ -1367,7 +1383,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         local_workspace = data["to"].split("/")[0];
       } else {
         if (this._local_workspace && this._local_workspace !== "*") {
-          (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+          (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
             data["to"].split("/")[0] === this._local_workspace,
             "Workspace mismatch: " +
               data["to"].split("/")[0] +
@@ -1402,6 +1418,13 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
             }
           }
           heartbeat_task = setInterval(heartbeat, promise.interval * 1000);
+          // Store the heartbeat task in the session store for cleanup
+          if (data.session) {
+            const session_store = this._get_session_store(data.session, false);
+            if (session_store) {
+              session_store.heartbeat_task = heartbeat_task;
+            }
+          }
         }
       }
 
@@ -1410,10 +1433,10 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       try {
         method = indexObject(this._object_store, data["method"]);
       } catch (e) {
-        // Clean promise method error handling
-        if (this._is_promise_method_call(data["method"])) {
+        // Simplified error handling like Python - just check if method exists
+        if (!this._object_store[data["method"].split(".")[0]]) {
           console.debug(
-            `Promise method ${data["method"]} not available (session settled or cleaned up), ignoring: ${method_name}`,
+            `Method ${data["method"]} not available (session cleaned up), ignoring: ${method_name}`,
           );
           return;
         }
@@ -1423,7 +1446,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         );
       }
 
-      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
         method && typeof method === "function",
         "Invalid method: " + method_name,
       );
@@ -1473,7 +1496,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       // Make sure the parent session is still open
       if (local_parent) {
         // The parent session should be a session that generate the current method call
-        (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
           this._get_session_store(local_parent, true) !== null,
           "Parent session was closed: " + local_parent,
         );
@@ -1494,18 +1517,30 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         this._method_annotations.has(method) &&
         this._method_annotations.get(method).require_context
       ) {
-        // if args.length + 1 is less than the required number of arguments we will pad with undefined
-        // so we make sure the last argument is the context
-        if (args.length + 1 < method.length) {
-          for (let i = args.length; i < method.length - 1; i++) {
-            args.push(undefined);
+        // Check if this is a remote service (from external clients)
+        // Remote services start with a session ID or client ID, not "services."
+        const isRemoteService = !data.method.startsWith("services.");
+
+        if (isRemoteService) {
+          // For remote services (external client services), the method.length reflects
+          // the original signature and cannot be modified. We inject context as the last argument
+          // and skip the strict argument validation that fails for external services.
+          args.push(data.ctx);
+        } else {
+          // For local services, use the existing logic with padding and validation
+          // if args.length + 1 is less than the required number of arguments we will pad with undefined
+          // so we make sure the last argument is the context
+          if (args.length + 1 < method.length) {
+            for (let i = args.length; i < method.length - 1; i++) {
+              args.push(undefined);
+            }
           }
+          args.push(data.ctx);
+          (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
+            args.length === method.length,
+            `Runtime Error: Invalid number of arguments for method ${method_name}, expected ${method.length} but got ${args.length}`,
+          );
         }
-        args.push(data.ctx);
-        (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
-          args.length === method.length,
-          `Runtime Error: Invalid number of arguments for method ${method_name}, expected ${method.length} but got ${args.length}`,
-        );
       }
       // console.debug(`Executing method: ${method_name} (${data.method})`);
       if (data.promise) {
@@ -1528,6 +1563,12 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         method.apply(null, args);
         clearInterval(heartbeat_task);
       }
+      if (data.session) {
+        const session_store = this._get_session_store(data.session, false);
+        if (session_store) {
+          delete session_store.heartbeat_task;
+        }
+      }
     } catch (err) {
       if (reject) {
         reject(err);
@@ -1623,23 +1664,23 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       return bObject;
     }
 
-    if ((0,_utils__WEBPACK_IMPORTED_MODULE_0__.isGenerator)(aObject) || (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isAsyncGenerator)(aObject)) {
+    if ((0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.isGenerator)(aObject) || (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.isAsyncGenerator)(aObject)) {
       // Handle generator functions and generator objects
-      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
         session_id && typeof session_id === "string",
         "Session ID is required for generator encoding",
       );
-      const object_id = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.randId)();
+      const object_id = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.randId)();
 
       // Get the session store
       const store = this._get_session_store(session_id, true);
-      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+      (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
         store !== null,
         `Failed to create session store ${session_id} due to invalid parent`,
       );
 
       // Check if it's an async generator
-      const isAsync = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isAsyncGenerator)(aObject);
+      const isAsync = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.isAsyncGenerator)(aObject);
 
       // Define method to get next item from the generator
       const nextItemMethod = async () => {
@@ -1687,12 +1728,12 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           _rname: aObject.name,
         };
       } else {
-        (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(typeof session_id === "string");
+        (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(typeof session_id === "string");
         let object_id;
         if (aObject.__name__) {
-          object_id = `${(0,_utils__WEBPACK_IMPORTED_MODULE_0__.randId)()}#${aObject.__name__}`;
+          object_id = `${(0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.randId)()}#${aObject.__name__}`;
         } else {
-          object_id = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.randId)();
+          object_id = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.randId)();
         }
         bObject = {
           _rtype: "method",
@@ -1703,7 +1744,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           _rname: aObject.name,
         };
         let store = this._get_session_store(session_id, true);
-        (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
           store !== null,
           `Failed to create session store ${session_id} due to invalid parent`,
         );
@@ -1769,7 +1810,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       if (!aObject.selection || !aObject.selection.data) {
         throw new Error("Invalid NumJS array: missing selection or data");
       }
-      const dtype = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(aObject.selection.data);
+      const dtype = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(aObject.selection.data);
       bObject = {
         _rtype: "ndarray",
         _rvalue: new Uint8Array(aObject.selection.data.buffer),
@@ -1832,7 +1873,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         seek: await this._encode(seek, session_id, local_workspace),
       };
     } else if (aObject instanceof ArrayBufferView) {
-      const dtype = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(aObject);
+      const dtype = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(aObject);
       bObject = {
         _rtype: "typedarray",
         _rvalue: new Uint8Array(aObject.buffer),
@@ -1964,7 +2005,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           if (Array.isArray(aObject._rvalue)) {
             aObject._rvalue = aObject._rvalue.reduce(_appendBuffer);
           }
-          const arraytype = _utils__WEBPACK_IMPORTED_MODULE_0__.dtypeToTypedArray[aObject._rdtype];
+          const arraytype = _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.dtypeToTypedArray[aObject._rdtype];
           bObject = tf.tensor(
             new arraytype(aObject._rvalue),
             aObject._rshape,
@@ -1979,7 +2020,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           "RemoteError: " + aObject._rvalue + "\n" + (aObject._rtrace || ""),
         );
       } else if (aObject._rtype === "typedarray") {
-        const arraytype = _utils__WEBPACK_IMPORTED_MODULE_0__.dtypeToTypedArray[aObject._rdtype];
+        const arraytype = _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.dtypeToTypedArray[aObject._rdtype];
         if (!arraytype)
           throw new Error("unsupported dtype: " + aObject._rdtype);
         const buffer = aObject._rvalue.buffer.slice(
@@ -2690,7 +2731,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   schemaFunction: () => (/* binding */ schemaFunction)
 /* harmony export */ });
-/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! . */ "./src/utils/index.js");
+/* harmony import */ var _index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index.js */ "./src/utils/index.js");
 
 
 function schemaFunction(
@@ -2700,9 +2741,9 @@ function schemaFunction(
   if (!func || typeof func !== "function") {
     throw Error("func should be a function");
   }
-  (0,___WEBPACK_IMPORTED_MODULE_0__.assert)(schema_type === "auto", "schema_type should be auto");
-  (0,___WEBPACK_IMPORTED_MODULE_0__.assert)(name, "name should not be null");
-  (0,___WEBPACK_IMPORTED_MODULE_0__.assert)(
+  (0,_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(schema_type === "auto", "schema_type should be auto");
+  (0,_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(name, "name should not be null");
+  (0,_index_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
     parameters && parameters.type === "object",
     "parameters should be an object",
   );
@@ -2729,7 +2770,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   registerRTCService: () => (/* binding */ registerRTCService)
 /* harmony export */ });
 /* harmony import */ var _rpc_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rpc.js */ "./src/rpc.js");
-/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/utils/index.js");
+/* harmony import */ var _utils_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils/index.js */ "./src/utils/index.js");
 /* harmony import */ var _utils_schema_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils/schema.js */ "./src/utils/schema.js");
 
 
@@ -2777,12 +2818,12 @@ class WebRTCConnection {
   }
 
   on_message(handler) {
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(handler, "handler is required");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(handler, "handler is required");
     this._handle_message = handler;
   }
 
   async emit_message(data) {
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(this._handle_message, "No handler for message");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(this._handle_message, "No handler for message");
     try {
       this._last_message = data;
       this._data_channel.send(data);
@@ -2801,10 +2842,10 @@ class WebRTCConnection {
 }
 
 async function _setupRPC(config) {
-  (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(config.channel, "No channel provided");
-  (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(config.workspace, "No workspace provided");
+  (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(config.channel, "No channel provided");
+  (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(config.workspace, "No workspace provided");
   const channel = config.channel;
-  const clientId = config.client_id || (0,_utils__WEBPACK_IMPORTED_MODULE_1__.randId)();
+  const clientId = config.client_id || (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.randId)();
   const connection = new WebRTCConnection(channel);
   config.context = config.context || {};
   config.context.connection_type = "webrtc";
@@ -2884,7 +2925,7 @@ async function _createOffer(params, server, config, onInit, context) {
 
 async function getRTCService(server, service_id, config) {
   config = config || {};
-  config.peer_id = config.peer_id || (0,_utils__WEBPACK_IMPORTED_MODULE_1__.randId)();
+  config.peer_id = config.peer_id || (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.randId)();
 
   const pc = new RTCPeerConnection({
     iceServers: config.ice_servers || [
@@ -2984,11 +3025,11 @@ async function getRTCService(server, service_id, config) {
               const rpc = await _setupRPC(config);
               pc.rpc = rpc;
               async function get_service(name, ...args) {
-                (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+                (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
                   !name.includes(":"),
                   "WebRTC service name should not contain ':'",
                 );
-                (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+                (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
                   !name.includes("/"),
                   "WebRTC service name should not contain '/'",
                 );
@@ -5073,14 +5114,14 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   connectToServer: () => (/* binding */ connectToServer),
 /* harmony export */   getRTCService: () => (/* reexport safe */ _webrtc_client_js__WEBPACK_IMPORTED_MODULE_3__.getRTCService),
 /* harmony export */   getRemoteService: () => (/* binding */ getRemoteService),
-/* harmony export */   loadRequirements: () => (/* reexport safe */ _utils__WEBPACK_IMPORTED_MODULE_1__.loadRequirements),
+/* harmony export */   loadRequirements: () => (/* reexport safe */ _utils_index_js__WEBPACK_IMPORTED_MODULE_1__.loadRequirements),
 /* harmony export */   login: () => (/* binding */ login),
 /* harmony export */   registerRTCService: () => (/* reexport safe */ _webrtc_client_js__WEBPACK_IMPORTED_MODULE_3__.registerRTCService),
 /* harmony export */   schemaFunction: () => (/* reexport safe */ _utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction),
 /* harmony export */   setupLocalClient: () => (/* binding */ setupLocalClient)
 /* harmony export */ });
 /* harmony import */ var _rpc_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rpc.js */ "./src/rpc.js");
-/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils */ "./src/utils/index.js");
+/* harmony import */ var _utils_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils/index.js */ "./src/utils/index.js");
 /* harmony import */ var _utils_schema_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils/schema.js */ "./src/utils/schema.js");
 /* harmony import */ var _webrtc_client_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./webrtc-client.js */ "./src/webrtc-client.js");
 
@@ -5105,7 +5146,7 @@ class WebsocketRPCConnection {
     WebSocketClass = null,
     token_refresh_interval = 2 * 60 * 60,
   ) {
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(server_url && client_id, "server_url and client_id are required");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(server_url && client_id, "server_url and client_id are required");
     this._server_url = server_url;
     this._client_id = client_id;
     this._workspace = workspace;
@@ -5146,7 +5187,7 @@ class WebsocketRPCConnection {
   }
 
   on_message(handler) {
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(handler, "handler is required");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(handler, "handler is required");
     this._handle_message = handler;
   }
 
@@ -5224,7 +5265,7 @@ class WebsocketRPCConnection {
         if (first_message.type == "connection_info") {
           this.connection_info = first_message;
           if (this._workspace) {
-            (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+            (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
               this.connection_info.workspace === this._workspace,
               `Connected to the wrong workspace: ${this.connection_info.workspace}, expected: ${this._workspace}`,
             );
@@ -5295,7 +5336,7 @@ class WebsocketRPCConnection {
       });
       this._websocket.send(authInfo);
       // Wait for the first message from the server
-      await (0,_utils__WEBPACK_IMPORTED_MODULE_1__.waitFor)(
+      await (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.waitFor)(
         this._establish_connection(),
         this._timeout,
         "Failed to receive the first message from the server",
@@ -5508,7 +5549,7 @@ async function login(config) {
   });
   try {
     const svc = await server.getService(service_id);
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(svc, `Failed to get the login service: ${service_id}`);
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(svc, `Failed to get the login service: ${service_id}`);
     let context;
     if (workspace) {
       context = await svc.start({ workspace, expires_in, _rkwargs: true });
@@ -5534,7 +5575,7 @@ async function webrtcGetService(wm, rtc_service_id, query, config) {
   const webrtc_config = config.webrtc_config;
   if (config.webrtc !== undefined) delete config.webrtc;
   if (config.webrtc_config !== undefined) delete config.webrtc_config;
-  (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+  (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
     [undefined, true, false, "auto"].includes(webrtc),
     "webrtc must be true, false or 'auto'",
   );
@@ -5572,7 +5613,7 @@ async function connectToServer(config) {
   }
   let clientId = config.client_id;
   if (!clientId) {
-    clientId = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.randId)();
+    clientId = (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.randId)();
     config.client_id = clientId;
   }
 
@@ -5588,7 +5629,7 @@ async function connectToServer(config) {
     config.WebSocketClass,
   );
   const connection_info = await connection.open();
-  (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+  (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
     connection_info,
     "Failed to connect to the server, no connection info obtained. This issue is most likely due to an outdated Hypha server version. Please use `imjoy-rpc` for compatibility, or upgrade the Hypha server to the latest version.",
   );
@@ -5647,11 +5688,11 @@ async function connectToServer(config) {
 
   async function getApp(clientId) {
     clientId = clientId || "*";
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(!clientId.includes(":"), "clientId should not contain ':'");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(!clientId.includes(":"), "clientId should not contain ':'");
     if (!clientId.includes("/")) {
       clientId = connection_info.workspace + "/" + clientId;
     }
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(
       clientId.split("/").length === 2,
       "clientId should match pattern workspace/clientId",
     );
@@ -5660,8 +5701,8 @@ async function connectToServer(config) {
 
   async function listApps(ws) {
     ws = ws || workspace;
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(!ws.includes(":"), "workspace should not contain ':'");
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(!ws.includes("/"), "workspace should not contain '/'");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(!ws.includes(":"), "workspace should not contain ':'");
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.assert)(!ws.includes("/"), "workspace should not contain '/'");
     const query = { workspace: ws, service_id: "default" };
     return await wm.listServices(query);
   }
@@ -5903,7 +5944,7 @@ async function connectToServer(config) {
 
 async function getRemoteService(serviceUri, config = {}) {
   const { serverUrl, workspace, clientId, serviceId, appId } =
-    (0,_utils__WEBPACK_IMPORTED_MODULE_1__.parseServiceUrl)(serviceUri);
+    (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.parseServiceUrl)(serviceUri);
   const fullServiceId = `${workspace}/${clientId}:${serviceId}@${appId}`;
 
   if (config.serverUrl) {