hypha-rpc 0.1.4 → 0.1.6-post1

package/index.js

@@ -1 +1 @@
-module.exports = { hyphaWebsocketClient: require("./dist/hypha-rpc-websocket.js"), hyphaSSEClient: require("./dist/hypha-rpc-sse.js") };
+module.exports = { hyphaWebsocketClient: require("./dist/hypha-rpc-websocket.js")};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypha-rpc",
-  "version": "0.1.4",
+  "version": "0.1.6-post1",
   "description": "Hypha RPC client for connecting to Hypha server for data management and AI model serving.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/rpc.js

@@ -210,7 +210,7 @@ export class RPC extends MessageEmitter {
       this._emit_message = connection.emit_message.bind(connection);
       connection.on_message(this._on_message.bind(this));
       this._connection = connection;
-      const updateServices = async () => {
+      const onConnected = async (connectionInfo) => {
         if (!this._silent && this._connection.manager_id) {
           console.log("Connection established, reporting services...");
           for (let service of Object.values(this._services)) {
@@ -223,12 +223,13 @@ export class RPC extends MessageEmitter {
           }
         } else {
           console.log(
-            "Connection established, no manager id to report services",
+            "Connection established", connectionInfo
           );
         }
+        this._fire("connected", connectionInfo);
       };
-      connection.on_connect(updateServices);
-      updateServices();
+      connection.on_connected(onConnected);
+      onConnected();
     } else {
       this._emit_message = function () {
         console.log("No connection to emit message");
@@ -366,7 +367,11 @@ export class RPC extends MessageEmitter {
         Object.assign(main, extra.value);
       }
       this._fire(main["type"], main);
-    } else {
+    }
+    else if (typeof message === "object") {
+      this._fire(message["type"], message);
+    }
+    else {
       throw new Error("Invalid message format");
     }
   }
@@ -377,7 +382,7 @@ export class RPC extends MessageEmitter {
   }
 
   async disconnect() {
-    this._fire("disconnect");
+    this._fire("disconnected");
     await this._connection.disconnect();
   }
 
@@ -457,7 +462,7 @@ export class RPC extends MessageEmitter {
       svc.id = `${provider}:${service_id}`;
       return svc;
     } catch (e) {
-      console.error("Failed to get remote service: " + service_uri, e);
+      console.warn("Failed to get remote service: " + service_uri, e);
       throw e;
     }
   }
@@ -769,8 +774,12 @@ export class RPC extends MessageEmitter {
   emit(main_message, extra_data) {
     assert(
       typeof main_message === "object" && main_message.type,
-      "Invalid message, must be an object with a type field.",
+      "Invalid message, must be an object with a `type` fields.",
     );
+    if(!main_message.to) {
+      this._fire(main_message.type, main_message);
+      return
+    }
     let message_package = msgpack_packb(main_message);
     if (extra_data) {
       const extra = msgpack_packb(extra_data);

package/src/webrtc-client.js

@@ -6,11 +6,11 @@ class WebRTCConnection {
     this._data_channel = channel;
     this._handle_message = null;
     this._reconnection_token = null;
-    this._disconnect_handler = null;
-    this._handle_connect = () => {};
+    this._handle_disconnected = null;
+    this._handle_connected = () => {};
     this.manager_id = null;
     this._data_channel.onopen = async () => {
-      this._handle_connect && this._handle_connect();
+      this._handle_connected && this._handle_connected({channel: this._data_channel});
     };
     this._data_channel.onmessage = async (event) => {
       let data = event.data;
@@ -21,18 +21,18 @@ class WebRTCConnection {
     };
     const self = this;
     this._data_channel.onclose = function () {
-      if (this._disconnect_handler) this._disconnect_handler("closed");
+      if (this._handle_disconnected) this._handle_disconnected("closed");
       console.log("websocket closed");
       self._data_channel = null;
     };
   }
 
   on_disconnected(handler) {
-    this._disconnect_handler = handler;
+    this._handle_disconnected = handler;
   }
 
-  on_connect(handler) {
-    this._handle_connect = handler;
+  on_connected(handler) {
+    this._handle_connected = handler;
   }
 
   on_message(handler) {

package/src/websocket-client.js

@@ -14,6 +14,7 @@ class WebsocketRPCConnection {
     client_id,
     workspace,
     token,
+    reconnection_token = null,
     timeout = 60,
     WebSocketClass = null,
   ) {
@@ -22,11 +23,11 @@ class WebsocketRPCConnection {
     this._client_id = client_id;
     this._workspace = workspace;
     this._token = token;
-    this._reconnection_token = null;
+    this._reconnection_token = reconnection_token;
     this._websocket = null;
     this._handle_message = null;
-    this._handle_connect = null; // Connection open event handler
-    this._disconnect_handler = null; // Disconnection event handler
+    this._handle_connected = null; // Connection open event handler
+    this._handle_disconnected = null; // Disconnection event handler
     this._timeout = timeout;
     this._WebSocketClass = WebSocketClass || WebSocket; // Allow overriding the WebSocket class
     this._closed = false;
@@ -41,12 +42,12 @@ class WebsocketRPCConnection {
     this._handle_message = handler;
   }
 
-  on_connect(handler) {
-    this._handle_connect = handler;
+  on_connected(handler) {
+    this._handle_connected = handler;
   }
 
   on_disconnected(handler) {
-    this._disconnect_handler = handler;
+    this._handle_disconnected = handler;
   }
 
   async _attempt_connection(server_url, attempt_fallback = true) {
@@ -74,8 +75,8 @@ class WebsocketRPCConnection {
           this._attempt_connection_with_query_params(server_url)
             .then(resolve)
             .catch(reject);
-        } else if (this._disconnect_handler) {
-          this._disconnect_handler(event.reason);
+        } else if (this._handle_disconnected) {
+          this._handle_disconnected(event.reason);
         }
       };
     });
@@ -127,15 +128,18 @@ class WebsocketRPCConnection {
           console.log(
             `Successfully connected to the server, workspace: ${this.connection_info.workspace}, manager_id: ${this.manager_id}`,
           );
+          if(this.connection_info.announcement){
+            console.log(`${this.connection_info.announcement}`);
+          }
           resolve(this.connection_info);
         } else if (first_message.type == "error") {
-          const error = first_message.error || "Unknown error";
+          const error = "ConnectionAbortedError: " + first_message.message;
           console.error("Failed to connect, " + error);
           reject(new Error(error));
           return;
         } else {
-          console.error("Unexpected message received from the server:", data);
-          reject(new Error("Unexpected message received from the server"));
+          console.error("ConnectionAbortedError: Unexpected message received from the server:", data);
+          reject(new Error("ConnectionAbortedError: Unexpected message received from the server"));
           return;
         }
       };
@@ -177,8 +181,8 @@ class WebsocketRPCConnection {
 
       this._websocket.onclose = this._handle_close.bind(this);
 
-      if (this._handle_connect) {
-        this._handle_connect(this);
+      if (this._handle_connected) {
+        this._handle_connected(this.connection_info);
       }
       return this.connection_info;
     } catch (error) {
@@ -197,14 +201,12 @@ class WebsocketRPCConnection {
       this._websocket &&
       this._websocket.readyState === WebSocket.CLOSED
     ) {
-      if ([1000].includes(event.code)) {
+      if ([1000, 1001].includes(event.code)) {
         console.info(
-          "Websocket connection closed (code: %s): %s",
-          event.code,
-          event.reason,
+          `Websocket connection closed (code: ${event.code}): ${event.reason}`  
         );
-        if (this._disconnect_handler) {
-          this._disconnect_handler(event.reason);
+        if (this._handle_disconnected) {
+          this._handle_disconnected(event.reason);
         }
         this._closed = true;
       } else if (this._enable_reconnect) {
@@ -216,10 +218,11 @@ class WebsocketRPCConnection {
         let retry = 0;
         const reconnect = async () => {
           try {
-            console.info(
+            console.warn(
               `Reconnecting to ${this._server_url.split("?")[0]} (attempt #${retry})`,
             );
             await this.open();
+            console.warn(`Successfully reconnected to server ${this._server_url}`); 
           } catch (e) {
             if (`${e}`.includes("ConnectionAbortedError")) {
               console.warn("Failed to reconnect, connection aborted:", e);
@@ -228,7 +231,6 @@ class WebsocketRPCConnection {
               console.warn("Failed to reconnect, connection aborted:", e);
               return;
             }
-            console.warn("Failed to reconnect:", e);
             await new Promise((resolve) => setTimeout(resolve, 1000));
             if (
               this._websocket &&
@@ -247,8 +249,8 @@ class WebsocketRPCConnection {
         reconnect();
       }
     } else {
-      if (this._disconnect_handler) {
-        this._disconnect_handler(event.reason);
+      if (this._handle_disconnected) {
+        this._handle_disconnected(event.reason);
       }
     }
   }
@@ -293,6 +295,7 @@ export async function login(config) {
   const service_id = config.login_service_id || "public/*:hypha-login";
   const timeout = config.login_timeout || 60;
   const callback = config.login_callback;
+  const profile = config.profile;
 
   const server = await connectToServer({
     name: "initial login client",
@@ -300,13 +303,14 @@ export async function login(config) {
   });
   try {
     const svc = await server.get_service(service_id);
+    assert(svc, `Failed to get the login service: ${service_id}`);
     const context = await svc.start();
     if (callback) {
       await callback(context);
     } else {
       console.log(`Please open your browser and login at ${context.login_url}`);
     }
-    return await svc.check(context.key, timeout);
+    return await svc.check(context.key, timeout, profile);
   } catch (error) {
     throw error;
   } finally {
@@ -333,6 +337,7 @@ export async function connectToServer(config) {
     clientId,
     config.workspace,
     config.token,
+    config.reconnection_token,
     config.method_timeout || 60,
     config.WebSocketClass,
   );
@@ -369,17 +374,13 @@ export async function connectToServer(config) {
     return await wm.get_service(query + ":default");
   }
 
-  async function disconnect() {
-    await rpc.disconnect();
-    await connection.disconnect();
-  }
   if (connection_info) {
     wm.config = Object.assign(wm.config, connection_info);
   }
   wm.export = _export;
   wm.getPlugin = getPlugin;
   wm.listPlugins = wm.listServices;
-  wm.disconnect = disconnect;
+  wm.disconnect = rpc.disconnect.bind(rpc);
   wm.registerCodec = rpc.register_codec.bind(rpc);
   wm.emit = rpc.emit;
   wm.on = rpc.on;
@@ -387,7 +388,7 @@ export async function connectToServer(config) {
     rpc.on("force-exit", async (message) => {
       if (message.from === "*/" + connection.manager_id) {
         console.log("Disconnecting from server, reason:", message.reason);
-        await disconnect();
+        await rpc.disconnect();
       }
     });
   }
@@ -401,7 +402,9 @@ export async function connectToServer(config) {
         [undefined, true, false, "auto"].includes(webrtc),
         "webrtc must be true, false or 'auto'",
       );
-      const svc = await _get_service(query);
+      // pass other arguments to get_service
+      const otherArgs = Array.prototype.slice.call(arguments, 3);
+      const svc = await _get_service(query, ...otherArgs);
       if (webrtc === true || webrtc === "auto") {
         if (svc.id.includes(":") && svc.id.includes("/")) {
           const client = svc.id.split(":")[0];