@makerbi/remodex 1.5.4 → 1.5.8

package/src/push-notification-service-client.js

@@ -5,6 +5,8 @@
 // Depends on: global fetch
 
 const DEFAULT_PUSH_SERVICE_TIMEOUT_MS = 10_000;
+const DEFAULT_PUSH_SERVICE_RETRY_LIMIT = 2;
+const DEFAULT_PUSH_SERVICE_RETRY_BASE_DELAY_MS = 500;
 
 function createPushNotificationServiceClient({
   baseUrl = "",
@@ -13,8 +15,16 @@ function createPushNotificationServiceClient({
   fetchImpl = globalThis.fetch,
   logPrefix = "[remodex]",
   requestTimeoutMs = DEFAULT_PUSH_SERVICE_TIMEOUT_MS,
+  retryLimit = DEFAULT_PUSH_SERVICE_RETRY_LIMIT,
+  retryBaseDelayMs = DEFAULT_PUSH_SERVICE_RETRY_BASE_DELAY_MS,
+  sleepImpl = sleep,
 } = {}) {
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const safeRetryLimit = normalizeNonNegativeInteger(retryLimit, DEFAULT_PUSH_SERVICE_RETRY_LIMIT);
+  const safeRetryBaseDelayMs = normalizeNonNegativeInteger(
+    retryBaseDelayMs,
+    DEFAULT_PUSH_SERVICE_RETRY_BASE_DELAY_MS
+  );
 
   async function registerDevice({
     deviceToken,
@@ -55,48 +65,70 @@ function createPushNotificationServiceClient({
       return { ok: false, skipped: true };
     }
 
-    const controller = typeof AbortController === "function" && requestTimeoutMs > 0
-      ? new AbortController()
-      : null;
-    const timeoutID = controller
-      ? setTimeout(() => {
-        controller.abort(createTimeoutAbortError(requestTimeoutMs));
-      }, requestTimeoutMs)
-      : null;
-
-    let response;
-    try {
-      response = await fetchImpl(`${normalizedBaseUrl}${pathname}`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-        },
-        body: JSON.stringify(payload),
-        signal: controller?.signal,
-      });
-    } catch (error) {
-      if (isAbortError(error)) {
-        const timeoutError = new Error(`Push service request timed out after ${requestTimeoutMs}ms`);
-        timeoutError.code = "push_request_timeout";
-        throw timeoutError;
+    const bodyJSON = JSON.stringify(payload);
+    let lastError = null;
+    for (let attempt = 0; attempt <= safeRetryLimit; attempt += 1) {
+      if (attempt > 0) {
+        const delayMs = safeRetryBaseDelayMs * Math.pow(2, attempt - 1);
+        if (delayMs > 0) {
+          await sleepImpl(delayMs);
+        }
       }
-      throw error;
-    } finally {
-      if (timeoutID) {
-        clearTimeout(timeoutID);
+
+      const controller = typeof AbortController === "function" && requestTimeoutMs > 0
+        ? new AbortController()
+        : null;
+      const timeoutID = controller
+        ? setTimeout(() => {
+          controller.abort(createTimeoutAbortError(requestTimeoutMs));
+        }, requestTimeoutMs)
+        : null;
+
+      let response;
+      try {
+        response = await fetchImpl(`${normalizedBaseUrl}${pathname}`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+          },
+          body: bodyJSON,
+          signal: controller?.signal,
+        });
+      } catch (error) {
+        lastError = error;
+        if (isAbortError(error)) {
+          continue;
+        }
+        if (isRetryableNetworkError(error)) {
+          continue;
+        }
+        throw error;
+      } finally {
+        if (timeoutID) {
+          clearTimeout(timeoutID);
+        }
+      }
+
+      const responseText = await response.text();
+      const parsed = safeParseJSON(responseText);
+      if (!response.ok) {
+        const message = parsed?.error || parsed?.message || responseText || `HTTP ${response.status}`;
+        const error = new Error(message);
+        error.status = response.status;
+        if (response.status >= 500 && attempt < safeRetryLimit) {
+          lastError = error;
+          continue;
+        }
+        throw error;
       }
-    }
 
-    const responseText = await response.text();
-    const parsed = safeParseJSON(responseText);
-    if (!response.ok) {
-      const message = parsed?.error || parsed?.message || responseText || `HTTP ${response.status}`;
-      const error = new Error(message);
-      error.status = response.status;
-      throw error;
+      return parsed ?? { ok: true };
     }
 
-    return parsed ?? { ok: true };
+    if (lastError) {
+      throw lastError;
+    }
+    return { ok: false };
   }
 
   return {
@@ -127,6 +159,7 @@ function normalizeBaseUrl(value) {
 function createTimeoutAbortError(timeoutMs) {
   const error = new Error(`Push service request timed out after ${timeoutMs}ms`);
   error.name = "AbortError";
+  error.code = "push_request_timeout";
   return error;
 }
 
@@ -134,6 +167,21 @@ function isAbortError(error) {
   return error?.name === "AbortError" || error?.code === "ABORT_ERR";
 }
 
+function isRetryableNetworkError(error) {
+  const code = error?.code ?? "";
+  return code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ETIMEDOUT"
+    || code === "ENETUNREACH" || code === "EHOSTUNREACH" || code === "ENOTFOUND"
+    || error?.message?.includes("fetch failed");
+}
+
+function normalizeNonNegativeInteger(value, fallback) {
+  return Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function sleep(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
 function safeParseJSON(value) {
   if (!value || typeof value !== "string") {
     return null;

package/src/push-notification-tracker.js

@@ -9,6 +9,9 @@ const {
 } = require("./push-notification-completion-dedupe");
 
 const DEFAULT_PREVIEW_MAX_CHARS = 160;
+const MAX_THREAD_TITLE_ENTRIES = 200;
+const MAX_TURN_STATE_ENTRIES = 500;
+const MAX_THREAD_ID_BY_TURN_ENTRIES = 500;
 
 function createPushNotificationTracker({
   sessionId,
@@ -73,6 +76,10 @@ function createPushNotificationTracker({
   // Remembers thread/turn linkage before the terminal event arrives on a different payload shape.
   function rememberMessageContext({ threadId, turnId, params, eventObject }) {
     if (threadId && turnId) {
+      if (!threadIdByTurnId.has(turnId) && threadIdByTurnId.size >= MAX_THREAD_ID_BY_TURN_ENTRIES) {
+        const oldest = threadIdByTurnId.keys().next().value;
+        threadIdByTurnId.delete(oldest);
+      }
       threadIdByTurnId.set(turnId, threadId);
       ensureTurnState(threadId, turnId);
     }
@@ -83,6 +90,10 @@ function createPushNotificationTracker({
 
     const nextTitle = extractThreadTitle(params, eventObject);
     if (nextTitle) {
+      if (!threadTitleById.has(threadId) && threadTitleById.size >= MAX_THREAD_TITLE_ENTRIES) {
+        const oldest = threadTitleById.keys().next().value;
+        threadTitleById.delete(oldest);
+      }
       threadTitleById.set(threadId, nextTitle);
     }
   }
@@ -225,6 +236,10 @@ function createPushNotificationTracker({
   function ensureTurnState(threadId, turnId) {
     const key = turnStateKey(threadId, turnId);
     if (!turnStateByKey.has(key)) {
+      if (turnStateByKey.size >= MAX_TURN_STATE_ENTRIES) {
+        const oldest = turnStateByKey.keys().next().value;
+        turnStateByKey.delete(oldest);
+      }
       turnStateByKey.set(key, {
         latestAssistantPreview: "",
         latestFailurePreview: "",