hypha-rpc 0.20.93 → 0.20.95

package/dist/hypha-rpc-websocket.js

@@ -30,13 +30,12 @@ __webpack_require__.r(__webpack_exports__);
 /* 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 _msgpack_msgpack__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @msgpack/msgpack */ "./node_modules/@msgpack/msgpack/dist.es5+esm/decode.mjs");
-/* harmony import */ var _msgpack_msgpack__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @msgpack/msgpack */ "./node_modules/@msgpack/msgpack/dist.es5+esm/encode.mjs");
 /**
  * HTTP Streaming RPC Client for Hypha.
  *
  * This module provides HTTP-based RPC transport as an alternative to WebSocket.
  * It uses:
- * - HTTP GET with streaming (NDJSON/msgpack) for server-to-client messages
+ * - HTTP GET with streaming (msgpack) for server-to-client messages
  * - HTTP POST for client-to-server messages
  *
  * This is more resilient to network issues than WebSocket because:
@@ -97,9 +96,7 @@ const MAX_RETRY = 1000000;
  * HTTP Streaming RPC Connection.
  *
  * Uses HTTP GET with streaming for receiving messages and HTTP POST for sending messages.
- * Supports two formats:
- * - NDJSON (default): JSON lines for text-based messages
- * - msgpack: Binary format with length-prefixed frames for binary data support
+ * Uses msgpack binary format with length-prefixed frames for efficient binary data support.
  */
 class HTTPStreamingRPCConnection {
   /**
@@ -112,7 +109,6 @@ class HTTPStreamingRPCConnection {
    * @param {string} reconnection_token - Token for reconnection (optional)
    * @param {number} timeout - Request timeout in seconds (default: 60)
    * @param {number} token_refresh_interval - Interval for token refresh (default: 2 hours)
-   * @param {string} format - Stream format - "json" (NDJSON) or "msgpack" (default: "json")
    */
   constructor(
     server_url,
@@ -122,7 +118,6 @@ class HTTPStreamingRPCConnection {
     reconnection_token = null,
     timeout = 60,
     token_refresh_interval = 2 * 60 * 60,
-    format = "json",
   ) {
     (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.replace(/\/$/, "");
@@ -132,7 +127,6 @@ class HTTPStreamingRPCConnection {
     this._reconnection_token = reconnection_token;
     this._timeout = timeout;
     this._token_refresh_interval = token_refresh_interval;
-    this._format = format;
 
     this._handle_message = null;
     this._handle_disconnected = null;
@@ -143,8 +137,7 @@ class HTTPStreamingRPCConnection {
     this.connection_info = null;
     this.manager_id = null;
 
-    this._stream_reader = null;
-    this._stream_controller = null;
+    this._abort_controller = null;
   }
 
   /**
@@ -172,7 +165,7 @@ class HTTPStreamingRPCConnection {
   /**
    * Get HTTP headers with authentication.
    *
-   * @param {boolean} for_stream - If true, set Accept header based on format preference
+   * @param {boolean} for_stream - If true, set Accept header for msgpack stream
    * @returns {Object} Headers object
    */
   _get_headers(for_stream = false) {
@@ -180,11 +173,7 @@ class HTTPStreamingRPCConnection {
       "Content-Type": "application/msgpack",
     };
     if (for_stream) {
-      if (this._format === "msgpack") {
-        headers["Accept"] = "application/x-msgpack-stream";
-      } else {
-        headers["Accept"] = "application/x-ndjson";
-      }
+      headers["Accept"] = "application/x-msgpack-stream";
     }
     if (this._token) {
       headers["Authorization"] = `Bearer ${this._token}`;
@@ -196,16 +185,11 @@ class HTTPStreamingRPCConnection {
    * Open the streaming connection.
    */
   async open() {
-    console.info(
-      `Opening HTTP streaming connection to ${this._server_url} (format=${this._format})`,
-    );
+    console.info(`Opening HTTP streaming connection to ${this._server_url}`);
 
-    // Build stream URL
-    const workspace = this._workspace || "public";
-    let stream_url = `${this._server_url}/${workspace}/rpc?client_id=${this._client_id}`;
-    if (this._format === "msgpack") {
-      stream_url += "&format=msgpack";
-    }
+    // Build stream URL - workspace is part of path, default to "public" for anonymous
+    const ws = this._workspace || "public";
+    const stream_url = `${this._server_url}/${ws}/rpc?client_id=${this._client_id}`;
 
     // Start streaming in background
     this._startStreamLoop(stream_url);
@@ -256,11 +240,11 @@ class HTTPStreamingRPCConnection {
       try {
         // OPTIMIZATION: Browser fetch automatically streams responses
         // and negotiates HTTP/2 when available for better performance
+        this._abort_controller = new AbortController();
         const response = await fetch(url, {
           method: "GET",
           headers: this._get_headers(true),
-          // keepalive flag for connection reuse (important for reconnections)
-          keepalive: true,
+          signal: this._abort_controller.signal,
         });
 
         if (!response.ok) {
@@ -272,13 +256,8 @@ class HTTPStreamingRPCConnection {
 
         retry = 0; // Reset retry counter on successful connection
 
-        if (this._format === "msgpack") {
-          // Binary msgpack stream with 4-byte length prefix
-          await this._processMsgpackStream(response);
-        } else {
-          // NDJSON stream (line-based)
-          await this._processNdjsonStream(response);
-        }
+        // Process binary msgpack stream with 4-byte length prefix
+        await this._processMsgpackStream(response);
       } catch (error) {
         if (this._closed) break;
         console.error(`Connection error: ${error.message}`);
@@ -305,36 +284,6 @@ class HTTPStreamingRPCConnection {
     }
   }
 
-  /**
-   * Process NDJSON (line-based JSON) stream.
-   */
-  async _processNdjsonStream(response) {
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    while (!this._closed) {
-      const { done, value } = await reader.read();
-
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-
-        try {
-          const message = JSON.parse(line);
-          await this._handleStreamMessage(message);
-        } catch (error) {
-          console.warn(`Failed to parse JSON message: ${error.message}`);
-        }
-      }
-    }
-  }
-
   /**
    * Check if frame data is a control message and decode it.
    *
@@ -445,40 +394,6 @@ class HTTPStreamingRPCConnection {
     }
   }
 
-  /**
-   * Handle a decoded stream message.
-   */
-  async _handleStreamMessage(message) {
-    // Handle connection info
-    if (message.type === "connection_info") {
-      this.connection_info = message;
-      return;
-    }
-
-    // Handle ping (keep-alive)
-    if (message.type === "ping") {
-      return;
-    }
-
-    // Handle reconnection token refresh
-    if (message.type === "reconnection_token") {
-      this._reconnection_token = message.reconnection_token;
-      return;
-    }
-
-    // Handle errors
-    if (message.type === "error") {
-      console.error(`Server error: ${message.message}`);
-      return;
-    }
-
-    // Pass to message handler (convert to msgpack for RPC)
-    if (this._handle_message) {
-      const data = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_4__.encode)(message);
-      await this._handle_message(data);
-    }
-  }
-
   /**
    * Send a message to the server via HTTP POST.
    *
@@ -493,20 +408,21 @@ class HTTPStreamingRPCConnection {
       throw new Error("Connection is closed");
     }
 
-    // Build POST URL - use the connected workspace
-    const workspace = this._workspace || "public";
-    const post_url = `${this._server_url}/${workspace}/rpc?client_id=${this._client_id}`;
+    // Build POST URL - workspace is part of path (must be set after connection)
+    const ws = this._workspace || "public";
+    let post_url = `${this._server_url}/${ws}/rpc?client_id=${this._client_id}`;
 
     // Ensure data is Uint8Array
     const body = data instanceof Uint8Array ? data : new Uint8Array(data);
 
-    // OPTIMIZATION: keepalive flag hints to browser to reuse connections
-    // This is particularly important for rapid successive requests
+    // Note: keepalive has a 64KB body size limit in browsers, so only use
+    // it for small payloads. For large payloads, skip keepalive.
+    const useKeepalive = body.length < 60000;
     const response = await fetch(post_url, {
       method: "POST",
       headers: this._get_headers(false),
       body: body,
-      keepalive: true,  // Enable connection reuse
+      ...(useKeepalive && { keepalive: true }),
     });
 
     if (!response.ok) {
@@ -534,6 +450,12 @@ class HTTPStreamingRPCConnection {
 
     this._closed = true;
 
+    // Abort any active stream fetch to release the connection immediately
+    if (this._abort_controller) {
+      this._abort_controller.abort();
+      this._abort_controller = null;
+    }
+
     if (this._handle_disconnected) {
       this._handle_disconnected(reason);
     }
@@ -582,8 +504,6 @@ async function _connectToServerHTTP(config) {
     config.reconnection_token,
     config.method_timeout || 30,
     config.token_refresh_interval || 2 * 60 * 60,
-    // Default to msgpack for full binary support and proper RPC message handling
-    config.format || "msgpack",
   );
 
   const connection_info = await connection.open();
@@ -603,15 +523,11 @@ async function _connectToServerHTTP(config) {
     server_base_url: connection_info.public_base_url,
   });
 
-  await (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_1__.waitFor)(
-    () => rpc._services_registered,
-    null,
-    config.method_timeout || 120,
-    "Timeout waiting for services to register",
-  );
+  await rpc.waitFor("services_registered", config.method_timeout || 120);
 
   const wm = await rpc.get_manager_service({
     timeout: config.method_timeout || 30,
+    case_conversion: "camel",
   });
   wm.rpc = rpc;
 
@@ -649,7 +565,7 @@ async function _connectToServerHTTP(config) {
   wm.serve = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(serve, {
     name: "serve",
     description: "Run event loop forever",
-    parameters: {},
+    parameters: { type: "object", properties: {} },
   });
 
   if (connection_info) {
@@ -1401,7 +1317,8 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       main["ctx"] = JSON.parse(JSON.stringify(main));
       Object.assign(main["ctx"], this.default_context);
       this._fire(main["type"], main);
-    } else if (message instanceof ArrayBuffer) {
+    } else if (message instanceof ArrayBuffer || ArrayBuffer.isView(message)) {
+      // Handle both ArrayBuffer (WebSocket) and Uint8Array/ArrayBufferView (HTTP transport)
       let unpacker = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__.decodeMulti)(message);
       const { done, value } = unpacker.next();
       const main = value;
@@ -1445,31 +1362,12 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       }
     }
 
-    // Unsubscribe from client_disconnected events if subscribed
+    // Clean up client_disconnected subscription
     if (this._clientDisconnectedSubscription) {
-      try {
-        // Get the manager service to unsubscribe (non-blocking)
-        if (this._connection && this._connection.manager_id) {
-          this.get_remote_service("*/" + this._connection.manager_id)
-            .then((manager) => {
-              if (
-                manager.unsubscribe &&
-                typeof manager.unsubscribe === "function"
-              ) {
-                return manager.unsubscribe("client_disconnected");
-              }
-            })
-            .catch((e) => {
-              console.debug(
-                `Error unsubscribing from client_disconnected: ${e}`,
-              );
-            });
-        }
-        // Remove the local event handler
-        this.off("client_disconnected");
-      } catch (e) {
-        console.debug(`Error unsubscribing from client_disconnected: ${e}`);
-      }
+      // Remove the local event handler (no need to unsubscribe from server -
+      // the server will clean up when it detects the disconnection)
+      this.off("client_disconnected");
+      this._clientDisconnectedSubscription = null;
     }
 
     // Clean up background tasks
@@ -2591,11 +2489,14 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   ) {
     let target_id = encoded_method._rtarget;
     if (remote_workspace && !target_id.includes("/")) {
-      if (remote_workspace !== target_id) {
-        target_id = remote_workspace + "/" + target_id;
+      // Don't modify target_id if it starts with */ (workspace manager service)
+      if (!target_id.startsWith("*/")) {
+        if (remote_workspace !== target_id) {
+          target_id = remote_workspace + "/" + target_id;
+        }
+        // Fix the target id to be an absolute id
+        encoded_method._rtarget = target_id;
       }
-      // Fix the target id to be an absolute id
-      encoded_method._rtarget = target_id;
     }
     let method_id = encoded_method._rmethod;
     let with_promise = encoded_method._rpromise || false;
@@ -7177,6 +7078,20 @@ function normalizeServerUrl(server_url) {
   return server_url;
 }
 
+/**
+ * Login to the hypha server.
+ *
+ * Configuration options:
+ *   server_url: The server URL (required)
+ *   workspace: Target workspace (optional)
+ *   login_service_id: Login service ID (default: "public/hypha-login")
+ *   expires_in: Token expiration time (optional)
+ *   login_timeout: Timeout for login process (default: 60)
+ *   login_callback: Callback function for login URL (optional)
+ *   profile: Whether to return user profile (optional)
+ *   additional_headers: Additional HTTP headers (optional)
+ *   transport: Transport type - "websocket" (default) or "http"
+ */
 async function login(config) {
   const service_id = config.login_service_id || "public/hypha-login";
   const workspace = config.workspace;
@@ -7185,11 +7100,13 @@ async function login(config) {
   const callback = config.login_callback;
   const profile = config.profile;
   const additional_headers = config.additional_headers;
+  const transport = config.transport || "websocket";
 
   const server = await connectToServer({
     name: "initial login client",
     server_url: config.server_url,
     additional_headers: additional_headers,
+    transport: transport,
   });
   try {
     const svc = await server.getService(service_id);
@@ -7213,15 +7130,27 @@ async function login(config) {
   }
 }
 
+/**
+ * Logout from the hypha server.
+ *
+ * Configuration options:
+ *   server_url: The server URL (required)
+ *   login_service_id: Login service ID (default: "public/hypha-login")
+ *   logout_callback: Callback function for logout URL (optional)
+ *   additional_headers: Additional HTTP headers (optional)
+ *   transport: Transport type - "websocket" (default) or "http"
+ */
 async function logout(config) {
   const service_id = config.login_service_id || "public/hypha-login";
   const callback = config.logout_callback;
   const additional_headers = config.additional_headers;
+  const transport = config.transport || "websocket";
 
   const server = await connectToServer({
     name: "initial logout client",
     server_url: config.server_url,
     additional_headers: additional_headers,
+    transport: transport,
   });
   try {
     const svc = await server.getService(service_id);