rivetkit 2.0.37 → 2.0.39

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

@@ -1,7 +1,7 @@
 import {
   importWebSocket,
   logger
-} from "./chunk-RXA3ZMCL.js";
+} from "./chunk-PHCD25XO.js";
 import {
   ACTOR_VERSIONED,
   ActionContext,
@@ -59,7 +59,7 @@ import {
   serializeWithEncoding,
   tryParseEndpoint,
   uint8ArrayToBase64
-} from "./chunk-5XGZXH74.js";
+} from "./chunk-PVKUXMOA.js";
 import {
   EXTRA_ERROR_LOG,
   SinglePromiseQueue,
@@ -84,7 +84,7 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-XI335ZED.js";
+} from "./chunk-CDK6DRO2.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;
@@ -384,13 +377,56 @@ async function apiCall(config, method, path, body) {
   });
 }
 
+// src/remote-manager-driver/actor-websocket-client.ts
+function buildActorGatewayUrl(endpoint, actorId, token, path = "") {
+  const tokenSegment = token !== void 0 ? `@${encodeURIComponent(token)}` : "";
+  const gatewayPath = `/gateway/${encodeURIComponent(actorId)}${tokenSegment}${path}`;
+  return combineUrlPath(endpoint, gatewayPath);
+}
+async function openWebSocketToActor(runConfig, path, actorId, encoding, params) {
+  const WebSocket2 = await importWebSocket();
+  const endpoint = getEndpoint(runConfig);
+  const guardUrl = buildActorGatewayUrl(
+    endpoint,
+    actorId,
+    runConfig.token,
+    path
+  );
+  logger3().debug({
+    msg: "opening websocket to actor via guard",
+    actorId,
+    path,
+    guardUrl
+  });
+  const ws = new WebSocket2(
+    guardUrl,
+    buildWebSocketProtocols(runConfig, encoding, params)
+  );
+  ws.binaryType = "arraybuffer";
+  logger3().debug({ msg: "websocket connection opened", actorId });
+  return ws;
+}
+function buildWebSocketProtocols(runConfig, encoding, params) {
+  const protocols = [];
+  protocols.push(WS_PROTOCOL_STANDARD);
+  protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
+  if (params) {
+    protocols.push(
+      `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+    );
+  }
+  return protocols;
+}
+
 // src/remote-manager-driver/actor-http-client.ts
 async function sendHttpRequestToActor(runConfig, actorId, actorRequest) {
   const url = new URL(actorRequest.url);
   const endpoint = getEndpoint(runConfig);
-  const guardUrl = combineUrlPath(
+  const guardUrl = buildActorGatewayUrl(
     endpoint,
-    `/gateway/${actorId}${url.pathname}${url.search}`
+    actorId,
+    runConfig.token,
+    `${url.pathname}${url.search}`
   );
   let bodyToSend = null;
   const guardHeaders = buildGuardHeadersForHttp(
@@ -434,43 +470,6 @@ function buildGuardHeadersForHttp(runConfig, actorRequest, actorId) {
   return headers;
 }
 
-// src/remote-manager-driver/actor-websocket-client.ts
-async function openWebSocketToActor(runConfig, path, actorId, encoding, params) {
-  const WebSocket2 = await importWebSocket();
-  const endpoint = getEndpoint(runConfig);
-  let gatewayPath;
-  if (runConfig.token !== void 0) {
-    gatewayPath = `/gateway/${encodeURIComponent(actorId)}@${encodeURIComponent(runConfig.token)}${path}`;
-  } else {
-    gatewayPath = `/gateway/${encodeURIComponent(actorId)}${path}`;
-  }
-  const guardUrl = combineUrlPath(endpoint, gatewayPath);
-  logger3().debug({
-    msg: "opening websocket to actor via guard",
-    actorId,
-    path,
-    guardUrl
-  });
-  const ws = new WebSocket2(
-    guardUrl,
-    buildWebSocketProtocols(runConfig, encoding, params)
-  );
-  ws.binaryType = "arraybuffer";
-  logger3().debug({ msg: "websocket connection opened", actorId });
-  return ws;
-}
-function buildWebSocketProtocols(runConfig, encoding, params) {
-  const protocols = [];
-  protocols.push(WS_PROTOCOL_STANDARD);
-  protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
-  if (params) {
-    protocols.push(
-      `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
-    );
-  }
-  return protocols;
-}
-
 // src/remote-manager-driver/api-endpoints.ts
 async function getActor(config, _, actorId) {
   return apiCall(
@@ -738,9 +737,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({
@@ -894,6 +901,13 @@ var RemoteManagerDriver = class {
       params
     );
   }
+  async buildGatewayUrl(actorId) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    const endpoint = getEndpoint(this.#config);
+    return buildActorGatewayUrl(endpoint, actorId, this.#config.token);
+  }
   async proxyRequest(_c, actorRequest, actorId) {
     if (this.#metadataPromise) {
       await this.#metadataPromise;
@@ -1018,6 +1032,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 +1274,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 +1379,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 +1404,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 +1432,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 +1449,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 +1568,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 +2026,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 +2082,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);
     }
   }
@@ -2088,9 +2152,7 @@ var ActorHandleRaw = class {
     );
   }
   /**
-   * Resolves the actor to get its unique actor ID
-   *
-   * @returns {Promise<string>} - A promise that resolves to the actor's ID
+   * Resolves the actor to get its unique actor ID.
    */
   async resolve({ signal } = {}) {
     if ("getForKey" in this.#actorQuery || "getOrCreateForKey" in this.#actorQuery) {
@@ -2117,6 +2179,17 @@ var ActorHandleRaw = class {
       assertUnreachable2(this.#actorQuery);
     }
   }
+  /**
+   * Returns the raw URL for routing traffic to the actor.
+   */
+  async getGatewayUrl() {
+    const { actorId } = await queryActor(
+      void 0,
+      this.#actorQuery,
+      this.#driver
+    );
+    return await this.#driver.buildGatewayUrl(actorId);
+  }
 };
 
 // src/client/client.ts
@@ -3995,7 +4068,7 @@ var ActorInstance = class {
     return this.#abortController.signal;
   }
   get actions() {
-    return Object.keys(this.#config.actions);
+    return Object.keys(this.#config.actions ?? {});
   }
   get config() {
     return this.#config;
@@ -4208,11 +4281,12 @@ var ActorInstance = class {
   // MARK: - Action Execution
   async executeAction(ctx, actionName, args) {
     this.assertReady();
-    if (!(actionName in this.#config.actions)) {
+    const actions = this.#config.actions ?? {};
+    if (!(actionName in actions)) {
       this.#rLog.warn({ msg: "action does not exist", actionName });
       throw new ActionNotFound(actionName);
     }
-    const actionFunction = this.#config.actions[actionName];
+    const actionFunction = actions[actionName];
     if (typeof actionFunction !== "function") {
       this.#rLog.warn({
         msg: "action is not a function",
@@ -4684,4 +4758,4 @@ export {
   RemoteManagerDriver,
   createClient
 };
-//# sourceMappingURL=chunk-ZQBSQ6H3.js.map
+//# sourceMappingURL=chunk-XU74APB4.js.map