rivetkit 2.0.37 → 2.0.38

package/dist/tsup/{chunk-ZQBSQ6H3.js → chunk-EEL32AJM.js}

@@ -1,7 +1,7 @@
 import {
   importWebSocket,
   logger
-} from "./chunk-RXA3ZMCL.js";
+} from "./chunk-WIZ4JGP6.js";
 import {
   ACTOR_VERSIONED,
   ActionContext,
@@ -59,7 +59,7 @@ import {
   serializeWithEncoding,
   tryParseEndpoint,
   uint8ArrayToBase64
-} from "./chunk-5XGZXH74.js";
+} from "./chunk-MIOU6BF3.js";
 import {
   EXTRA_ERROR_LOG,
   SinglePromiseQueue,
@@ -84,7 +84,7 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-XI335ZED.js";
+} from "./chunk-4U45T5KW.js";
 import {
   ActionNotFound,
   ActionTimedOut,
@@ -169,46 +169,39 @@ var ActorConnDisposed = class extends ActorClientError {
     super("Attempting to interact with a disposed actor connection.");
   }
 };
-var ActorSchedulingError = class _ActorSchedulingError extends ActorClientError {
+function isSchedulingError(group, code) {
+  return group === "guard" && (code === "actor_ready_timeout" || code === "actor_runner_failed");
+}
+var ActorSchedulingError = class extends ActorError {
   actorId;
-  errorType;
   details;
-  constructor(actorId, error) {
-    const message = _ActorSchedulingError.formatMessage(error);
-    super(message);
+  constructor(group, code, actorId, details) {
+    super(
+      group,
+      code,
+      `Actor failed to start (${actorId}): ${JSON.stringify(details)}`,
+      { actorId, details }
+    );
     this.name = "ActorSchedulingError";
     this.actorId = actorId;
-    this.errorType = Object.keys(error)[0];
-    this.details = error;
-  }
-  static formatMessage(error) {
-    if ("serverless_error" in error) {
-      const se = error.serverless_error;
-      if (typeof se === "string") {
-        return `Serverless error: ${se.replace(/_/g, " ")}`;
-      }
-      if ("http_error" in se) {
-        return `Serverless HTTP ${se.http_error.status_code}: ${se.http_error.body}`;
-      }
-      if ("connection_error" in se) {
-        return `Serverless connection error: ${se.connection_error.message}`;
-      }
-      if ("invalid_payload" in se) {
-        return `Invalid serverless payload: ${se.invalid_payload.message}`;
-      }
-      return "Unknown serverless error";
-    }
-    if ("no_capacity" in error) {
-      return `No capacity available for runner: ${error.no_capacity.runner_name}`;
-    }
-    if ("runner_no_response" in error) {
-      return `Runner ${error.runner_no_response.runner_id} did not respond`;
-    }
-    return "Unknown scheduling error";
+    this.details = details;
   }
 };
 
 // src/client/utils.ts
+function parseWebSocketCloseReason(reason) {
+  const [mainPart, rayId] = reason.split("#");
+  const [group, code] = mainPart.split(".");
+  if (!group || !code) {
+    logger().warn({ msg: "failed to parse close reason", reason });
+    return void 0;
+  }
+  return {
+    group,
+    code,
+    rayId
+  };
+}
 function messageLength(message) {
   if (message instanceof Blob) {
     return message.size;
@@ -738,9 +731,17 @@ var RemoteManagerDriver = class {
         (metadataData) => {
           if (metadataData.clientEndpoint) {
             this.#config.endpoint = metadataData.clientEndpoint;
+            if (metadataData.clientNamespace) {
+              this.#config.namespace = metadataData.clientNamespace;
+            }
+            if (metadataData.clientToken) {
+              this.#config.token = metadataData.clientToken;
+            }
             logger3().info({
-              msg: "overriding cached client endpoint",
-              endpoint: metadataData.clientEndpoint
+              msg: "overriding client endpoint",
+              endpoint: metadataData.clientEndpoint,
+              namespace: metadataData.clientNamespace,
+              token: metadataData.clientToken
             });
           }
           logger3().info({
@@ -1018,6 +1019,34 @@ async function queryActor(c, query, managerDriver) {
   logger().debug({ msg: "actor query result", actorId: actorOutput.actorId });
   return { actorId: actorOutput.actorId };
 }
+function getActorNameFromQuery(query) {
+  if ("getForId" in query) return query.getForId.name;
+  if ("getForKey" in query) return query.getForKey.name;
+  if ("getOrCreateForKey" in query) return query.getOrCreateForKey.name;
+  if ("create" in query) return query.create.name;
+  throw new InvalidRequest("Invalid query format");
+}
+async function checkForSchedulingError(group, code, actorId, query, driver) {
+  const name = getActorNameFromQuery(query);
+  try {
+    const actor = await driver.getForId({ name, actorId });
+    if (actor == null ? void 0 : actor.error) {
+      logger().info({
+        msg: "found actor scheduling error",
+        actorId,
+        error: actor.error
+      });
+      return new ActorSchedulingError(group, code, actorId, actor.error);
+    }
+  } catch (err) {
+    logger().warn({
+      msg: "failed to fetch actor details for scheduling error check",
+      actorId,
+      error: stringifyError(err)
+    });
+  }
+  return null;
+}
 
 // src/client/actor-conn.ts
 var CONNECT_SYMBOL = Symbol("connect");
@@ -1232,9 +1261,9 @@ var ActorConnRaw = class {
         });
       }
     });
-    ws.addEventListener("close", (ev) => {
+    ws.addEventListener("close", async (ev) => {
       try {
-        this.#handleOnClose(ev);
+        await this.#handleOnClose(ev);
       } catch (err) {
         logger().error({
           msg: "error in websocket close handler",
@@ -1337,17 +1366,23 @@ var ActorConnRaw = class {
           message,
           metadata
         });
-        let errorToThrow;
-        if (group === "guard" && (code === "actor_ready_timeout" || code === "actor_runner_failed") && this.#actorId) {
-          const schedulingError = await this.#checkForSchedulingError();
-          errorToThrow = schedulingError ?? new ActorError(group, code, message, metadata);
-        } else {
-          errorToThrow = new ActorError(
+        let errorToThrow = new ActorError(
+          group,
+          code,
+          message,
+          metadata
+        );
+        if (isSchedulingError(group, code) && this.#actorId) {
+          const schedulingError = await checkForSchedulingError(
             group,
             code,
-            message,
-            metadata
+            this.#actorId,
+            this.#actorQuery,
+            this.#driver
           );
+          if (schedulingError) {
+            errorToThrow = schedulingError;
+          }
         }
         if (this.#onOpenPromise) {
           this.#onOpenPromise.reject(errorToThrow);
@@ -1356,9 +1391,7 @@ var ActorConnRaw = class {
           inFlight.reject(errorToThrow);
           this.#actionsInFlight.delete(id);
         }
-        if (errorToThrow instanceof ActorError) {
-          this.#dispatchActorError(errorToThrow);
-        }
+        this.#dispatchActorError(errorToThrow);
       }
     } else if (response.body.tag === "ActionResponse") {
       const { id: actionId } = response.body.val;
@@ -1386,7 +1419,7 @@ var ActorConnRaw = class {
     }
   }
   /** Called by the onclose event from drivers. */
-  #handleOnClose(event) {
+  async #handleOnClose(event) {
     const closeEvent = event;
     const wasClean = closeEvent.wasClean;
     const wasConnected = this.#connStatus === "connected";
@@ -1403,12 +1436,46 @@ var ActorConnRaw = class {
       this.#rejectPendingPromises(new ActorConnDisposed(), true);
     } else {
       this.#setConnStatus("disconnected");
-      this.#rejectPendingPromises(
-        new Error(
-          `${wasClean ? "Connection closed" : "Connection lost"} (code: ${closeEvent.code}, reason: ${closeEvent.reason})`
-        ),
-        false
-      );
+      let error;
+      const reason = closeEvent.reason || "";
+      const parsed = parseWebSocketCloseReason(reason);
+      if (parsed) {
+        const { group, code } = parsed;
+        if (isSchedulingError(group, code) && this.#actorId) {
+          const schedulingError = await checkForSchedulingError(
+            group,
+            code,
+            this.#actorId,
+            this.#actorQuery,
+            this.#driver
+          );
+          if (schedulingError) {
+            error = schedulingError;
+          } else {
+            error = new ActorError(
+              group,
+              code,
+              `Connection closed: ${reason}`,
+              void 0
+            );
+          }
+        } else {
+          error = new ActorError(
+            group,
+            code,
+            `Connection closed: ${reason}`,
+            void 0
+          );
+        }
+      } else {
+        error = new Error(
+          `${wasClean ? "Connection closed" : "Connection lost"} (code: ${closeEvent.code}, reason: ${reason})`
+        );
+      }
+      this.#rejectPendingPromises(error, false);
+      if (error instanceof ActorError) {
+        this.#dispatchActorError(error);
+      }
       if (wasConnected) {
         logger().debug({
           msg: "triggering reconnect",
@@ -1488,36 +1555,6 @@ var ActorConnRaw = class {
       }
     }
   }
-  async #checkForSchedulingError() {
-    if (!this.#actorId) return null;
-    const query = this.#actorQuery;
-    const name = "getForId" in query ? query.getForId.name : "getForKey" in query ? query.getForKey.name : "getOrCreateForKey" in query ? query.getOrCreateForKey.name : "create" in query ? query.create.name : null;
-    if (!name) return null;
-    try {
-      const actor = await this.#driver.getForId({
-        name,
-        actorId: this.#actorId
-      });
-      if (actor == null ? void 0 : actor.error) {
-        logger().info({
-          msg: "found actor scheduling error",
-          actorId: this.#actorId,
-          error: actor.error
-        });
-        return new ActorSchedulingError(
-          this.#actorId,
-          actor.error
-        );
-      }
-    } catch (err) {
-      logger().warn({
-        msg: "failed to fetch actor details for scheduling error check",
-        actorId: this.#actorId,
-        error: stringifyError(err)
-      });
-    }
-    return null;
-  }
   #addEventSubscription(eventName, callback, once) {
     const listener = {
       callback,
@@ -1976,12 +2013,14 @@ var ActorHandleRaw = class {
    * @template Response - The type of the response returned by the action function.
    */
   async action(opts) {
+    let actorId;
     try {
-      const { actorId } = await queryActor(
+      const result = await queryActor(
         void 0,
         this.#actorQuery,
         this.#driver
       );
+      actorId = result.actorId;
       logger().debug({ msg: "found actor for action", actorId });
       invariant5(actorId, "Missing actor ID");
       logger().debug({
@@ -2030,6 +2069,18 @@ var ActorHandleRaw = class {
         {},
         true
       );
+      if (actorId && isSchedulingError(group, code)) {
+        const schedulingError = await checkForSchedulingError(
+          group,
+          code,
+          actorId,
+          this.#actorQuery,
+          this.#driver
+        );
+        if (schedulingError) {
+          throw schedulingError;
+        }
+      }
       throw new ActorError(group, code, message, metadata);
     }
   }
@@ -4684,4 +4735,4 @@ export {
   RemoteManagerDriver,
   createClient
 };
-//# sourceMappingURL=chunk-ZQBSQ6H3.js.map
+//# sourceMappingURL=chunk-EEL32AJM.js.map