rivetkit 2.3.30 → 3.0.0-preview.2

package/dist/tsup/{chunk-I472KTIC.js → chunk-6IGGYL2C.js}

@@ -1,14 +1,15 @@
 import {
+  actorKeyToGatewayQuery,
   deserializeActorKey,
   serializeActorKey
-} from "./chunk-JI6GZ2C2.js";
+} from "./chunk-A2CF6PFH.js";
 import {
   AsyncMutex
 } from "./chunk-JTHHCZCZ.js";
 import {
   importWebSocket,
   logger
-} from "./chunk-H3SGQEHZ.js";
+} from "./chunk-WGKL7HMH.js";
 import {
   EncodingSchema,
   assertUnreachable,
@@ -35,7 +36,7 @@ import {
   serializeWithEncoding,
   stringifyError,
   uint8ArrayToBase64
-} from "./chunk-CORYIKDC.js";
+} from "./chunk-5F7FWAJI.js";
 import {
   INTERNAL_ERROR_CODE,
   RivetError,
@@ -2176,6 +2177,56 @@ function readRequestBody(request) {
   ).arrayBuffer();
 }
 
+// src/client/retry-budget.ts
+var DEFAULT_PERCENT = 10;
+var DEFAULT_MAX_TOKENS = 100;
+var RetryBudget = class {
+  #tokens;
+  #maxTokens;
+  #deposit;
+  constructor(options = {}) {
+    const percent = options.percent ?? DEFAULT_PERCENT;
+    const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+    if (!(percent >= 0 && percent <= 100)) {
+      throw new Error("retryBudget.percent must be in 0..=100");
+    }
+    if (!(maxTokens >= 0)) {
+      throw new Error("retryBudget.maxTokens must be at least 0");
+    }
+    this.#maxTokens = maxTokens;
+    this.#tokens = maxTokens;
+    this.#deposit = percent / 100;
+  }
+  /** Credits one request sent. */
+  deposit() {
+    this.#tokens = Math.min(this.#maxTokens, this.#tokens + this.#deposit);
+  }
+  /** Spends one token. Returns `false` when the budget is spent. */
+  tryWithdraw() {
+    if (this.#tokens + 1e-9 < 1) {
+      return false;
+    }
+    this.#tokens = Math.max(0, this.#tokens - 1);
+    return true;
+  }
+};
+function retryAfterMs(error) {
+  if (!(error instanceof RivetError)) {
+    return void 0;
+  }
+  const metadata = error.metadata;
+  if (metadata === null || typeof metadata !== "object") {
+    return void 0;
+  }
+  const hint = metadata.retry_after_ms;
+  return typeof hint === "number" && hint >= 0 ? hint : void 0;
+}
+function retryDelayMs(attempt, opts) {
+  const backoff = Math.min(opts.initialDelayMs * 2 ** attempt, opts.maxDelayMs);
+  const jittered = backoff / 2 + Math.random() * (backoff / 2);
+  return Math.max(jittered, opts.hintMs ?? 0);
+}
+
 // src/client/lifecycle-errors.ts
 function* walkErrorChain(error, maxDepth = 8) {
   let current = error;
@@ -2351,9 +2402,11 @@ async function waitWithSignal(ms, signal) {
   });
 }
 async function retryOnLifecycleBoundary(run, opts) {
+  var _a;
   const maxAttempts = (opts == null ? void 0 : opts.maxAttempts) ?? 5;
   const initialDelayMs = (opts == null ? void 0 : opts.initialDelayMs) ?? 25;
   const maxDelayMs = (opts == null ? void 0 : opts.maxDelayMs) ?? 200;
+  (_a = opts == null ? void 0 : opts.budget) == null ? void 0 : _a.deposit();
   let lastError;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     throwIfAborted(opts == null ? void 0 : opts.signal);
@@ -2367,7 +2420,14 @@ async function retryOnLifecycleBoundary(run, opts) {
       if (attempt === maxAttempts - 1) {
         break;
       }
-      const delayMs = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
+      if ((opts == null ? void 0 : opts.budget) && !opts.budget.tryWithdraw()) {
+        break;
+      }
+      const delayMs = retryDelayMs(attempt, {
+        initialDelayMs,
+        maxDelayMs,
+        hintMs: retryAfterMs(error)
+      });
       await waitWithSignal(delayMs, opts == null ? void 0 : opts.signal);
     }
   }
@@ -2460,17 +2520,22 @@ function addOutboundTelemetryHeaders(headers, telemetry) {
 
 // src/client/utils.ts
 import invariant from "invariant";
+var RETRY_AFTER_SUFFIX = /^retry_after_ms=(\d+)$/;
 function parseWebSocketCloseReason(reason) {
-  const [mainPart, rayId] = reason.split("#");
+  const [mainPart, suffix] = reason.split("#");
   const [group, code] = mainPart.split(".");
   if (!group || !code) {
     logger().warn({ msg: "failed to parse close reason", reason });
     return void 0;
   }
+  const retryAfter = suffix == null ? void 0 : suffix.match(RETRY_AFTER_SUFFIX);
+  if (retryAfter) {
+    return { group, code, retryAfterMs: Number(retryAfter[1]) };
+  }
   return {
     group,
     code,
-    rayId
+    rayId: suffix
   };
 }
 function messageLength(message) {
@@ -2868,6 +2933,7 @@ var ActorHandleRaw = class {
   #queueSendMutex = new AsyncMutex();
   #currentActorInvocation;
   #startCallSpan;
+  #retryBudget;
   /**
    * Do not call this directly.
    *
@@ -2875,7 +2941,7 @@ var ActorHandleRaw = class {
    *
    * @protected
    */
-  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}, signal, currentActorInvocation, startCallSpan) {
+  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}, signal, currentActorInvocation, startCallSpan, retryBudget = new RetryBudget()) {
     this.#client = client;
     this.#driver = driver;
     this.#encoding = encoding;
@@ -2886,6 +2952,7 @@ var ActorHandleRaw = class {
     this.#signal = signal;
     this.#currentActorInvocation = currentActorInvocation;
     this.#startCallSpan = startCallSpan;
+    this.#retryBudget = retryBudget;
   }
   async #resolveConnectionParams() {
     if (this.#getParams) {
@@ -2902,6 +2969,7 @@ var ActorHandleRaw = class {
       let useQueryTarget = isDynamicActorQuery(
         this.#actorResolutionState
       );
+      this.#retryBudget.deposit();
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         let actorId;
         try {
@@ -2938,8 +3006,17 @@ var ActorHandleRaw = class {
             metadata,
             attempt,
             maxAttempts
-          )) {
-            await this.#waitForRetryWindow();
+          ) && this.#retryBudget.tryWithdraw()) {
+            await new Promise(
+              (resolve) => setTimeout(
+                resolve,
+                retryDelayMs(attempt, {
+                  initialDelayMs: 25,
+                  maxDelayMs: 1e3,
+                  hintMs: retryAfterMs(err)
+                })
+              )
+            );
             continue;
           }
           if (await this.#shouldRetrySchedulingError(
@@ -3016,7 +3093,10 @@ var ActorHandleRaw = class {
       if (opts.name === "destroy") {
         return await run();
       }
-      return await retryOnLifecycleBoundary(run, { signal });
+      return await retryOnLifecycleBoundary(run, {
+        signal,
+        budget: this.#retryBudget
+      });
     };
     if (!call) {
       return await send();
@@ -3558,6 +3638,7 @@ var ClientRaw = class {
   #gatewayOptions;
   #currentActorInvocation;
   #startCallSpan;
+  #retryBudget;
   /**
    * Creates an instance of Client.
    */
@@ -3570,6 +3651,7 @@ var ClientRaw = class {
     this.#gatewayOptions = options.gateway ?? {};
     this.#currentActorInvocation = options.currentActorInvocation;
     this.#startCallSpan = options.startCallSpan;
+    this.#retryBudget = new RetryBudget(options.retryBudget);
   }
   /**
    * Gets a stateless handle to a actor by its ID.
@@ -3727,7 +3809,8 @@ var ClientRaw = class {
       this.#gatewayOptions,
       signal,
       this.#currentActorInvocation,
-      this.#startCallSpan
+      this.#startCallSpan,
+      this.#retryBudget
     );
   }
   [CREATE_ACTOR_CONN_PROXY](conn) {
@@ -3927,6 +4010,10 @@ function jwtExpiration(token) {
 }
 
 // src/client/actor-conn.ts
+var CONNECT_TIMEOUT_MS = 2e4;
+function isConnectionOpenTimeout(error) {
+  return error instanceof RivetError && error.group === "client" && error.code === "connection_open_timeout";
+}
 var CONNECT_SYMBOL = /* @__PURE__ */ Symbol("connect");
 var ActorConnRaw = class {
   #disposed = false;
@@ -3954,6 +4041,8 @@ var ActorConnRaw = class {
   #keepNodeAliveInterval;
   /** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */
   #onOpenPromise;
+  /** Sockets given up on by the connect timeout. Their late events are ignored. */
+  #abandonedSockets = /* @__PURE__ */ new WeakSet();
   #websocket;
   #authRetryAvailable = true;
   #client;
@@ -4144,12 +4233,16 @@ var ActorConnRaw = class {
       forever: true,
       minTimeout: 250,
       maxTimeout: 3e4,
-      onFailedAttempt: (error) => {
+      onFailedAttempt: async (error) => {
         logger().warn({
           msg: "failed to reconnect",
           attempt: error.attemptNumber,
           error: stringifyError(error)
         });
+        const hintMs = retryAfterMs(error);
+        if (hintMs !== void 0) {
+          await new Promise((resolve) => setTimeout(resolve, hintMs));
+        }
       },
       // Cancel retry if aborted
       signal: this.#abortController.signal
@@ -4175,7 +4268,7 @@ var ActorConnRaw = class {
         })
       );
       await this.#connectWebSocket();
-      await this.#onOpenPromise.promise;
+      await this.#waitForOpen(this.#onOpenPromise.promise);
     } catch (error) {
       if (this.#shouldRetryConnectionOpenError(error)) {
         throw error;
@@ -4197,10 +4290,63 @@ var ActorConnRaw = class {
       this.#onOpenPromise = void 0;
     }
   }
+  /**
+   * Waits for the actor's Init on the current socket, up to {@link CONNECT_TIMEOUT_MS}. A socket
+   * can stay connecting with no open, error or close event, as when the engine holds the
+   * upgrade or a refused connect reports only an error. On timeout the socket is abandoned
+   * and closed, and the retryable `client.connection_open_timeout` starts the next attempt.
+   */
+  async #waitForOpen(open) {
+    let timer;
+    const timedOut = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new RivetError(
+            "client",
+            "connection_open_timeout",
+            `Connection did not open within ${CONNECT_TIMEOUT_MS} ms`
+          )
+        );
+      }, CONNECT_TIMEOUT_MS);
+    });
+    try {
+      await Promise.race([open, timedOut]);
+    } catch (error) {
+      if (isConnectionOpenTimeout(error)) {
+        this.#abandonCurrentSocket();
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  #abandonCurrentSocket() {
+    const ws = this.#websocket;
+    if (!ws) return;
+    this.#websocket = void 0;
+    this.#abandonedSockets.add(ws);
+    logger().warn({
+      msg: "connection did not open in time, retrying",
+      connId: this.#connId,
+      readyState: ws.readyState,
+      timeoutMs: CONNECT_TIMEOUT_MS
+    });
+    try {
+      ws.close(1e3, "Connect timeout");
+    } catch (err) {
+      logger().debug({
+        msg: "failed to close abandoned websocket",
+        error: stringifyError(err)
+      });
+    }
+  }
   #shouldRetryConnectionOpenError(error) {
     if (error instanceof ActorConnDisposed) {
       return false;
     }
+    if (isConnectionOpenTimeout(error)) {
+      return true;
+    }
     if (error instanceof RivetError && isInvalidToken(error.group, error.code) && this.#driver.refreshAuthToken && this.#authRetryAvailable) {
       this.#authRetryAvailable = false;
       return true;
@@ -4260,12 +4406,14 @@ var ActorConnRaw = class {
     });
     this.#websocket = ws;
     ws.addEventListener("open", () => {
+      if (this.#abandonedSockets.has(ws)) return;
       logger().debug({
         msg: "client websocket open",
         connId: this.#connId
       });
     });
     ws.addEventListener("message", async (ev) => {
+      if (this.#abandonedSockets.has(ws)) return;
       try {
         await this.#handleOnMessage(ev.data);
       } catch (err) {
@@ -4276,6 +4424,7 @@ var ActorConnRaw = class {
       }
     });
     ws.addEventListener("close", async (ev) => {
+      if (this.#abandonedSockets.has(ws)) return;
       try {
         await this.#handleOnClose(ev);
       } catch (err) {
@@ -4286,6 +4435,7 @@ var ActorConnRaw = class {
       }
     });
     ws.addEventListener("error", () => {
+      if (this.#abandonedSockets.has(ws)) return;
       try {
         this.#handleOnError();
       } catch (err) {
@@ -4494,7 +4644,8 @@ var ActorConnRaw = class {
       const reason = closeEvent.reason || "";
       const parsed = parseWebSocketCloseReason(reason);
       if (parsed) {
-        const { group, code, rayId } = parsed;
+        const { group, code, rayId, retryAfterMs: retryAfterMs2 } = parsed;
+        const closeOptions = retryAfterMs2 === void 0 ? { rayId } : { rayId, metadata: { retry_after_ms: retryAfterMs2 } };
         if (isInvalidToken(group, code) && closeEvent.code === 1008 && failedSocket) {
           try {
             if (!await ((_b = (_a = this.#driver).refreshAuthToken) == null ? void 0 : _b.call(
@@ -4517,7 +4668,7 @@ var ActorConnRaw = class {
               group,
               code,
               `Connection closed: ${reason}`,
-              { rayId }
+              closeOptions
             )
           );
           return;
@@ -4538,7 +4689,7 @@ var ActorConnRaw = class {
               group,
               code,
               `Connection closed: ${reason}`,
-              { rayId }
+              closeOptions
             );
           }
         } else {
@@ -4546,7 +4697,7 @@ var ActorConnRaw = class {
             group,
             code,
             `Connection closed: ${reason}`,
-            { rayId }
+            closeOptions
           );
         }
         this.#invalidateActorIfStale(group, code);
@@ -5164,6 +5315,14 @@ var ClientConfigSchemaBase = z2.object({
   // This is required in the client config in order to support
   // `proxyWebSocket`
   getUpgradeWebSocket: z2.custom().optional(),
+  /**
+   * Bounds retries of refused requests: `percent` retries per 100 requests (default 10), with
+   * up to `maxTokens` banked for bursts (default 100). A refusal past the budget is thrown.
+   */
+  retryBudget: z2.object({
+    percent: z2.number().min(0).max(100).optional(),
+    maxTokens: z2.number().int().min(0).optional()
+  }).optional(),
   /** Replaces global fetch for actor HTTP gateway requests. */
   fetch: z2.custom().optional(),
   /** Whether to automatically perform health checks when the client is created. */
@@ -5206,7 +5365,7 @@ function convertRegistryConfigToClientConfig(config) {
     token: config.token,
     getToken: void 0,
     namespace: config.namespace,
-    poolName: config.envoy.poolName,
+    poolName: config.node.poolName,
     headers: config.headers,
     gateway: { skipReadyWait: false },
     encoding: "bare",
@@ -5533,8 +5692,9 @@ function buildActorQueryGatewayUrl(endpoint, namespace, query, token, path = "",
   return combineUrlPath(endpoint, gatewayPath);
 }
 function pushKeyQueryParams(params, key) {
-  if (key.length > 0) {
-    params.append("rvt-key", key.join(","));
+  const rvtKey = actorKeyToGatewayQuery(key);
+  if (rvtKey !== void 0) {
+    params.append("rvt-key", rvtKey);
   }
 }
 function pushInputQueryParam(params, input, maxInputSize) {
@@ -5716,8 +5876,8 @@ async function updateRunnerConfig(config, runnerName, request) {
   return apiCall(
     config,
     "PUT",
-    `/runner-configs/${runnerName}`,
-    request
+    `/pools/${encodeURIComponent(runnerName)}`,
+    Object.values(request.datacenters)[0]
   );
 }
 
@@ -6050,7 +6210,7 @@ var RemoteEngineControlClient = class {
           datacenter: region,
           name,
           key: serializeActorKey(key),
-          runner_name_selector: poolName ?? this.#config.poolName,
+          pool: poolName ?? this.#config.poolName,
           input: actorInput ? uint8ArrayToBase64(
             encodeCborCompat(actorInput)
           ) : void 0,
@@ -6103,7 +6263,7 @@ var RemoteEngineControlClient = class {
       (config) => createActor(config, {
         datacenter: region,
         name,
-        runner_name_selector: poolName ?? this.#config.poolName,
+        pool: poolName ?? this.#config.poolName,
         key: serializeActorKey(key),
         input: input ? uint8ArrayToBase64(
           encodeCborCompat(input)
@@ -6369,4 +6529,4 @@ export {
   updateRunnerConfig,
   RemoteEngineControlClient
 };
-//# sourceMappingURL=chunk-I472KTIC.js.map
+//# sourceMappingURL=chunk-6IGGYL2C.js.map