@wildix/xbees-conversations-utils 1.1.92 → 1.2.0

package/dist-cjs/index.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./normalization"), exports);
-tslib_1.__exportStar(require("./streamRateLimitHandlingProxy"), exports);
 tslib_1.__exportStar(require("./stream"), exports);
+tslib_1.__exportStar(require("./streamRateLimitHandlingProxy"), exports);
 tslib_1.__exportStar(require("./types"), exports);

package/dist-cjs/streamRateLimitHandlingProxy/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_OPTIONS = exports.SOFT_THROTTLE_DELAY_HIGH_MS = exports.SOFT_THROTTLE_DELAY_MEDIUM_MS = exports.SOFT_THROTTLE_DELAY_LOW_MS = exports.SOFT_THROTTLE_USAGE_HIGH = exports.SOFT_THROTTLE_USAGE_MEDIUM = exports.SOFT_THROTTLE_USAGE_LOW = exports.BUDGET_COOLDOWN_SLEEP_CHUNK_MS = exports.BUDGET_MINIMAL_DELAY_MAX_MS = exports.BUDGET_MINIMAL_DELAY_MIN_MS = exports.BUDGET_RELAXED_DELAY_MAX_MS = exports.BUDGET_RELAXED_DELAY_MIN_MS = exports.BUDGET_RELAXED_USAGE_THRESHOLD = exports.BUDGET_CLEAR_USAGE_THRESHOLD = exports.BUDGET_DELAY_MAX_MS = exports.BUDGET_DELAY_MIN_MS = exports.BUDGET_THRESHOLD = exports.STREAM_BUDGET_COOLDOWN_KEY = exports.STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX = exports.STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY = exports.STREAM_RATE_LIMIT_OPTIONS_MARKER = exports.STREAM_BUDGET_COOLDOWN_KEY_PREFIX = exports.STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = exports.RETRY_AFTER_BUFFER_MS = exports.DEFAULT_JITTER_MS = exports.DEFAULT_RETRY_AFTER_MS = exports.DEFAULT_MAX_DELAY_MS = exports.STREAM_SYNC_METHOD_NAMES = exports.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = exports.STREAM_METHOD_NAMES = exports.STREAM_CHANNEL_RESULT_METHOD_NAMES = exports.CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = exports.CHANNEL_SYNC_METHOD_NAMES = exports.CHANNEL_METHOD_NAMES = void 0;
+exports.DEFAULT_OPTIONS = exports.SOFT_THROTTLE_DELAY_HIGH_MS = exports.SOFT_THROTTLE_DELAY_MEDIUM_MS = exports.SOFT_THROTTLE_DELAY_LOW_MS = exports.SOFT_THROTTLE_USAGE_HIGH = exports.SOFT_THROTTLE_USAGE_MEDIUM = exports.SOFT_THROTTLE_USAGE_LOW = exports.BUDGET_COOLDOWN_SLEEP_CHUNK_MS = exports.BUDGET_MINIMAL_DELAY_MAX_MS = exports.BUDGET_MINIMAL_DELAY_MIN_MS = exports.BUDGET_RELAXED_DELAY_MAX_MS = exports.BUDGET_RELAXED_DELAY_MIN_MS = exports.BUDGET_RELAXED_USAGE_THRESHOLD = exports.BUDGET_CLEAR_USAGE_THRESHOLD = exports.BUDGET_DELAY_MAX_MS = exports.BUDGET_DELAY_MIN_MS = exports.BUDGET_THRESHOLD = exports.STREAM_BUDGET_COOLDOWN_KEY = exports.STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX = exports.STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY = exports.STREAM_RATE_LIMIT_OPTIONS_MARKER = exports.STREAM_BUDGET_COOLDOWN_KEY_PREFIX = exports.STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX = exports.RETRY_AFTER_BUFFER_MS = exports.DEFAULT_JITTER_MS = exports.DEFAULT_RETRY_AFTER_MS = exports.STREAM_SYNC_METHOD_NAMES = exports.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = exports.STREAM_METHOD_NAMES = exports.STREAM_CHANNEL_RESULT_METHOD_NAMES = exports.CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = exports.CHANNEL_SYNC_METHOD_NAMES = exports.CHANNEL_METHOD_NAMES = void 0;
 var generatedMethodNames_1 = require("./generatedMethodNames");
 Object.defineProperty(exports, "CHANNEL_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.CHANNEL_METHOD_NAMES; } });
 Object.defineProperty(exports, "CHANNEL_SYNC_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.CHANNEL_SYNC_METHOD_NAMES; } });
@@ -9,7 +9,6 @@ Object.defineProperty(exports, "STREAM_CHANNEL_RESULT_METHOD_NAMES", { enumerabl
 Object.defineProperty(exports, "STREAM_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.STREAM_METHOD_NAMES; } });
 Object.defineProperty(exports, "STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES; } });
 Object.defineProperty(exports, "STREAM_SYNC_METHOD_NAMES", { enumerable: true, get: function () { return generatedMethodNames_1.STREAM_SYNC_METHOD_NAMES; } });
-exports.DEFAULT_MAX_DELAY_MS = 5000;
 exports.DEFAULT_RETRY_AFTER_MS = 10000;
 exports.DEFAULT_JITTER_MS = 150;
 exports.RETRY_AFTER_BUFFER_MS = 1000;

package/dist-cjs/streamRateLimitHandlingProxy/helpers/createRateLimitExceededException.js

@@ -13,12 +13,9 @@ function toEpochSecondsFromNow(delayMs) {
 function createRateLimitExceededException(options = {}) {
     const { rateLimit, message, operation, retryAfterMs = constants_1.DEFAULT_RETRY_AFTER_MS } = options;
     const defaultMessage = operation ? `Rate limit exceeded for ${operation}` : 'Rate limit exceeded';
-    const retryAfterFromResetMs = rateLimit?.reset ? rateLimit.reset - Date.now() : undefined;
+    const retryAfterFromResetMs = rateLimit?.reset != null ? rateLimit.reset - Date.now() : undefined;
     const effectiveRetryAfterMs = retryAfterFromResetMs ?? retryAfterMs;
     const retryAfterMilliseconds = toPositiveMilliseconds(effectiveRetryAfterMs);
-    const rateLimitResetMilliseconds = rateLimit?.reset
-        ? toPositiveMilliseconds(retryAfterFromResetMs ?? 0)
-        : retryAfterMilliseconds;
     const retryAfterEpochSeconds = toEpochSecondsFromNow(effectiveRetryAfterMs + RETRY_AFTER_HEADER_PADDING_MS);
     return new xbees_conversations_client_1.RateLimitExceededException({
         $metadata: {},
@@ -26,7 +23,7 @@ function createRateLimitExceededException(options = {}) {
         rateLimitRemaining: rateLimit?.remaining || 0,
         retryAfter: retryAfterEpochSeconds,
         rateLimit: rateLimit?.limit?.toString() || 'unknown',
-        rateLimitReset: rateLimitResetMilliseconds,
+        rateLimitReset: retryAfterMilliseconds,
     });
 }
 exports.createRateLimitExceededException = createRateLimitExceededException;

package/dist-cjs/streamRateLimitHandlingProxy/helpers/executeWithRateLimitHandling.js

@@ -11,15 +11,12 @@ function calculateRateLimitDelayMs(error, maxDelayMs) {
     const retryAfterMs = typeof error.rateLimitReset === 'number' && error.rateLimitReset > 0 ? error.rateLimitReset : 0;
     const hasServerRetryAfter = retryAfterMs > 0;
     const baseDelayMs = hasServerRetryAfter ? retryAfterMs + constants_1.RETRY_AFTER_BUFFER_MS : constants_1.DEFAULT_RETRY_AFTER_MS;
-    if (baseDelayMs > 0) {
-        const jitterMs = Math.floor(Math.random() * constants_1.DEFAULT_JITTER_MS);
-        const computedDelayMs = baseDelayMs + jitterMs;
-        if (hasServerRetryAfter) {
-            return computedDelayMs;
-        }
-        return Math.min(maxDelayMs, computedDelayMs);
+    const jitterMs = Math.floor(Math.random() * constants_1.DEFAULT_JITTER_MS);
+    const computedDelayMs = baseDelayMs + jitterMs;
+    if (hasServerRetryAfter) {
+        return computedDelayMs;
     }
-    return Math.min(maxDelayMs, constants_1.DEFAULT_MAX_DELAY_MS);
+    return Math.min(maxDelayMs, computedDelayMs);
 }
 function getRateLimitMetadataKey(operation) {
     return `${operation}${constants_1.STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX}`;
@@ -49,25 +46,31 @@ function toRateLimitSnapshot(error) {
         reset: Date.now() + resetMs,
     };
 }
+async function throwIfOperationCooldownActive(operation, context) {
+    const { logger, redis } = context;
+    const cooldownMs = await RedisCooldown_1.RedisCooldown.getRemainingMs(operation, { redis, logger });
+    if (cooldownMs <= 0) {
+        return;
+    }
+    const rateLimitSnapshot = (0, rateLimitSnapshot_1.parseRateLimitSnapshot)(await RedisCooldown_1.RedisCooldown.getValue(getRateLimitMetadataKey(operation), { redis, logger }));
+    logger.warn('Skipping stream request due to active rate-limit cooldown', {
+        operation,
+        cooldown: cooldownMs,
+        rateLimitSnapshot,
+    });
+    throw (0, createRateLimitExceededException_1.createRateLimitExceededException)({
+        operation,
+        retryAfterMs: cooldownMs,
+        rateLimit: rateLimitSnapshot ? toCooldownRateLimit(rateLimitSnapshot, cooldownMs) : undefined,
+    });
+}
 async function executeWithRateLimitHandling(execute, operation, context, options) {
     const { logger, redis } = context;
     const { enableCooldown, maxAttempts, maxDelayMs, maxRetryableDelayMs } = options;
     let attempt = 1;
     if (enableCooldown) {
-        const cooldownMs = await RedisCooldown_1.RedisCooldown.getRemainingMs(operation, { redis, logger });
-        if (cooldownMs > 0) {
-            const rateLimitSnapshot = (0, rateLimitSnapshot_1.parseRateLimitSnapshot)(await RedisCooldown_1.RedisCooldown.getValue(getRateLimitMetadataKey(operation), { redis, logger }));
-            logger.warn('Skipping stream request due to active rate-limit cooldown', {
-                operation,
-                cooldown: cooldownMs,
-                rateLimitSnapshot,
-            });
-            throw (0, createRateLimitExceededException_1.createRateLimitExceededException)({
-                operation,
-                retryAfterMs: cooldownMs,
-                rateLimit: rateLimitSnapshot ? toCooldownRateLimit(rateLimitSnapshot, cooldownMs) : undefined,
-            });
-        }
+        await throwIfOperationCooldownActive(operation, { logger, redis });
+        let waitedForSharedCooldown = false;
         const softCooldownMs = await RedisCooldown_1.RedisCooldown.getRemainingMs(constants_1.STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, { redis, logger }, { keyPrefix: constants_1.STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX });
         if (softCooldownMs > 0) {
             logger.info('Delaying stream request due to active soft rate-limit cooldown', {
@@ -75,6 +78,7 @@ async function executeWithRateLimitHandling(execute, operation, context, options
                 cooldown: softCooldownMs,
             });
             await (0, promises_1.setTimeout)(softCooldownMs);
+            waitedForSharedCooldown = true;
         }
         const budgetCooldownMs = await RedisCooldown_1.RedisCooldown.getRemainingMs(constants_1.STREAM_BUDGET_COOLDOWN_KEY, { redis, logger }, { keyPrefix: constants_1.STREAM_BUDGET_COOLDOWN_KEY_PREFIX });
         if (budgetCooldownMs > 0) {
@@ -88,11 +92,15 @@ async function executeWithRateLimitHandling(execute, operation, context, options
                 if (waitMs <= 0 || totalBudgetWaitMs >= constants_1.BUDGET_DELAY_MAX_MS) {
                     break;
                 }
-                const chunkMs = Math.min(waitMs, constants_1.BUDGET_COOLDOWN_SLEEP_CHUNK_MS);
+                const chunkMs = Math.min(waitMs, constants_1.BUDGET_COOLDOWN_SLEEP_CHUNK_MS, constants_1.BUDGET_DELAY_MAX_MS - totalBudgetWaitMs);
                 await (0, promises_1.setTimeout)(chunkMs);
                 totalBudgetWaitMs += chunkMs;
+                waitedForSharedCooldown = true;
             }
         }
+        if (waitedForSharedCooldown) {
+            await throwIfOperationCooldownActive(operation, { logger, redis });
+        }
     }
     for (;;) {
         try {

package/dist-cjs/streamRateLimitHandlingProxy/helpers/headerUtils.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeResetToEpochMs = exports.parseHeaderNumber = exports.getHeaderCaseInsensitive = void 0;
+const EPOCH_SECONDS_PAST_SKEW_SECONDS = 60;
+const EPOCH_SECONDS_FUTURE_SKEW_SECONDS = 24 * 60 * 60;
 function getHeaderCaseInsensitive(headers, key) {
     if (!headers) {
         return;
@@ -31,10 +33,16 @@ function parseHeaderNumber(headers, key) {
 }
 exports.parseHeaderNumber = parseHeaderNumber;
 function normalizeResetToEpochMs(reset) {
-    if (reset < 10000)
-        return Date.now() + Math.round(reset * 1000);
-    if (reset < 10000000000)
+    const nowMs = Date.now();
+    if (!Number.isFinite(reset)) {
+        return nowMs;
+    }
+    if (reset >= 10000000000)
+        return Math.round(reset);
+    const nowSeconds = nowMs / 1000;
+    const looksLikeEpochSeconds = reset >= nowSeconds - EPOCH_SECONDS_PAST_SKEW_SECONDS && reset <= nowSeconds + EPOCH_SECONDS_FUTURE_SKEW_SECONDS;
+    if (looksLikeEpochSeconds)
         return Math.round(reset * 1000);
-    return Math.round(reset);
+    return nowMs + Math.round(reset * 1000);
 }
 exports.normalizeResetToEpochMs = normalizeResetToEpochMs;

package/dist-cjs/streamRateLimitHandlingProxy/helpers/processStreamBudgetHeaders.js

@@ -19,7 +19,7 @@ function isBudgetThresholdReached(limitMs, remainingMs, usedMs) {
         return true;
     }
     if (typeof remainingMs === 'number') {
-        const remainingThreshold = Math.ceil((1 - constants_1.BUDGET_THRESHOLD) * limitMs);
+        const remainingThreshold = (1 - constants_1.BUDGET_THRESHOLD) * limitMs;
         return remainingMs <= remainingThreshold;
     }
     return false;
@@ -45,7 +45,7 @@ async function processStreamBudgetHeaders(headers, context) {
     if (limitMs === undefined && remainingMs === undefined && usedMs === undefined) {
         return;
     }
-    if (typeof limitMs !== 'number' || !Number.isFinite(limitMs)) {
+    if (typeof limitMs !== 'number' || !Number.isFinite(limitMs) || limitMs <= 0) {
         return;
     }
     const usage = getBudgetUsage(limitMs, remainingMs, usedMs);

package/dist-cjs/streamRateLimitHandlingProxy/helpers/processStreamRateLimitHeaders.js

@@ -10,9 +10,6 @@ function computeSoftThrottleUsage(limit, remaining) {
     }
     return Math.max(0, 1 - remaining / limit);
 }
-function toUsagePercent(usage) {
-    return Math.round(usage * 10000) / 100;
-}
 function computeSoftThrottleDelayMs(limit, remaining) {
     const usage = computeSoftThrottleUsage(limit, remaining);
     if (usage >= constants_1.SOFT_THROTTLE_USAGE_HIGH) {

package/dist-cjs/streamRateLimitHandlingProxy/helpers/registerStreamInterceptors.js

@@ -35,24 +35,30 @@ function registerStreamInterceptors(stream, context) {
         return;
     }
     attachedInterceptors.add(axiosInstance);
-    axiosInstance.interceptors.response.use(async (response) => {
-        try {
-            await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(response?.headers, context);
-            await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(response?.headers, context);
-        }
-        catch (error) {
-            logger.warn('Failed to process Stream response headers in interceptor', { error });
-        }
-        return response;
-    }, async (error) => {
-        try {
-            await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(error?.response?.headers, context);
-            await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(error?.response?.headers, context);
-        }
-        catch (interceptorError) {
-            logger.warn('Failed to process Stream error headers in interceptor', { error: interceptorError });
-        }
-        return Promise.reject(error);
-    });
+    try {
+        axiosInstance.interceptors.response.use(async (response) => {
+            try {
+                await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(response?.headers, context);
+                await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(response?.headers, context);
+            }
+            catch (error) {
+                logger.warn('Failed to process Stream response headers in interceptor', { error });
+            }
+            return response;
+        }, async (error) => {
+            try {
+                await (0, processStreamBudgetHeaders_1.processStreamBudgetHeaders)(error?.response?.headers, context);
+                await (0, processStreamRateLimitHeaders_1.processStreamRateLimitHeaders)(error?.response?.headers, context);
+            }
+            catch (interceptorError) {
+                logger.warn('Failed to process Stream error headers in interceptor', { error: interceptorError });
+            }
+            return Promise.reject(error);
+        });
+    }
+    catch (error) {
+        attachedInterceptors.delete(axiosInstance);
+        logger.warn('Failed to register Stream response interceptors', { error });
+    }
 }
 exports.registerStreamInterceptors = registerStreamInterceptors;

package/dist-es/index.js

@@ -1,4 +1,4 @@
 export * from './normalization';
-export * from './streamRateLimitHandlingProxy';
 export * from './stream';
+export * from './streamRateLimitHandlingProxy';
 export * from './types';

package/dist-es/streamRateLimitHandlingProxy/constants.js

@@ -1,5 +1,4 @@
 export { CHANNEL_METHOD_NAMES, CHANNEL_SYNC_METHOD_NAMES, CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES, STREAM_CHANNEL_RESULT_METHOD_NAMES, STREAM_METHOD_NAMES, STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES, STREAM_SYNC_METHOD_NAMES, } from './generatedMethodNames';
-export const DEFAULT_MAX_DELAY_MS = 5000;
 export const DEFAULT_RETRY_AFTER_MS = 10000;
 export const DEFAULT_JITTER_MS = 150;
 export const RETRY_AFTER_BUFFER_MS = 1000;

package/dist-es/streamRateLimitHandlingProxy/helpers/createRateLimitExceededException.js

@@ -10,12 +10,9 @@ function toEpochSecondsFromNow(delayMs) {
 export function createRateLimitExceededException(options = {}) {
     const { rateLimit, message, operation, retryAfterMs = DEFAULT_RETRY_AFTER_MS } = options;
     const defaultMessage = operation ? `Rate limit exceeded for ${operation}` : 'Rate limit exceeded';
-    const retryAfterFromResetMs = rateLimit?.reset ? rateLimit.reset - Date.now() : undefined;
+    const retryAfterFromResetMs = rateLimit?.reset != null ? rateLimit.reset - Date.now() : undefined;
     const effectiveRetryAfterMs = retryAfterFromResetMs ?? retryAfterMs;
     const retryAfterMilliseconds = toPositiveMilliseconds(effectiveRetryAfterMs);
-    const rateLimitResetMilliseconds = rateLimit?.reset
-        ? toPositiveMilliseconds(retryAfterFromResetMs ?? 0)
-        : retryAfterMilliseconds;
     const retryAfterEpochSeconds = toEpochSecondsFromNow(effectiveRetryAfterMs + RETRY_AFTER_HEADER_PADDING_MS);
     return new RateLimitExceededException({
         $metadata: {},
@@ -23,6 +20,6 @@ export function createRateLimitExceededException(options = {}) {
         rateLimitRemaining: rateLimit?.remaining || 0,
         retryAfter: retryAfterEpochSeconds,
         rateLimit: rateLimit?.limit?.toString() || 'unknown',
-        rateLimitReset: rateLimitResetMilliseconds,
+        rateLimitReset: retryAfterMilliseconds,
     });
 }

package/dist-es/streamRateLimitHandlingProxy/helpers/executeWithRateLimitHandling.js

@@ -1,5 +1,5 @@
 import { setTimeout as sleep } from 'node:timers/promises';
-import { BUDGET_COOLDOWN_SLEEP_CHUNK_MS, BUDGET_DELAY_MAX_MS, DEFAULT_JITTER_MS, DEFAULT_MAX_DELAY_MS, DEFAULT_RETRY_AFTER_MS, RETRY_AFTER_BUFFER_MS, STREAM_BUDGET_COOLDOWN_KEY, STREAM_BUDGET_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX, STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, } from '../constants';
+import { BUDGET_COOLDOWN_SLEEP_CHUNK_MS, BUDGET_DELAY_MAX_MS, DEFAULT_JITTER_MS, DEFAULT_RETRY_AFTER_MS, RETRY_AFTER_BUFFER_MS, STREAM_BUDGET_COOLDOWN_KEY, STREAM_BUDGET_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX, STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, } from '../constants';
 import { createRateLimitExceededException } from './createRateLimitExceededException';
 import { processStreamRateLimitException } from './processStreamRateLimitException';
 import { parseRateLimitSnapshot, serializeRateLimitSnapshot } from './rateLimitSnapshot';
@@ -8,15 +8,12 @@ function calculateRateLimitDelayMs(error, maxDelayMs) {
     const retryAfterMs = typeof error.rateLimitReset === 'number' && error.rateLimitReset > 0 ? error.rateLimitReset : 0;
     const hasServerRetryAfter = retryAfterMs > 0;
     const baseDelayMs = hasServerRetryAfter ? retryAfterMs + RETRY_AFTER_BUFFER_MS : DEFAULT_RETRY_AFTER_MS;
-    if (baseDelayMs > 0) {
-        const jitterMs = Math.floor(Math.random() * DEFAULT_JITTER_MS);
-        const computedDelayMs = baseDelayMs + jitterMs;
-        if (hasServerRetryAfter) {
-            return computedDelayMs;
-        }
-        return Math.min(maxDelayMs, computedDelayMs);
+    const jitterMs = Math.floor(Math.random() * DEFAULT_JITTER_MS);
+    const computedDelayMs = baseDelayMs + jitterMs;
+    if (hasServerRetryAfter) {
+        return computedDelayMs;
     }
-    return Math.min(maxDelayMs, DEFAULT_MAX_DELAY_MS);
+    return Math.min(maxDelayMs, computedDelayMs);
 }
 function getRateLimitMetadataKey(operation) {
     return `${operation}${STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX}`;
@@ -46,25 +43,31 @@ function toRateLimitSnapshot(error) {
         reset: Date.now() + resetMs,
     };
 }
+async function throwIfOperationCooldownActive(operation, context) {
+    const { logger, redis } = context;
+    const cooldownMs = await RedisCooldown.getRemainingMs(operation, { redis, logger });
+    if (cooldownMs <= 0) {
+        return;
+    }
+    const rateLimitSnapshot = parseRateLimitSnapshot(await RedisCooldown.getValue(getRateLimitMetadataKey(operation), { redis, logger }));
+    logger.warn('Skipping stream request due to active rate-limit cooldown', {
+        operation,
+        cooldown: cooldownMs,
+        rateLimitSnapshot,
+    });
+    throw createRateLimitExceededException({
+        operation,
+        retryAfterMs: cooldownMs,
+        rateLimit: rateLimitSnapshot ? toCooldownRateLimit(rateLimitSnapshot, cooldownMs) : undefined,
+    });
+}
 export async function executeWithRateLimitHandling(execute, operation, context, options) {
     const { logger, redis } = context;
     const { enableCooldown, maxAttempts, maxDelayMs, maxRetryableDelayMs } = options;
     let attempt = 1;
     if (enableCooldown) {
-        const cooldownMs = await RedisCooldown.getRemainingMs(operation, { redis, logger });
-        if (cooldownMs > 0) {
-            const rateLimitSnapshot = parseRateLimitSnapshot(await RedisCooldown.getValue(getRateLimitMetadataKey(operation), { redis, logger }));
-            logger.warn('Skipping stream request due to active rate-limit cooldown', {
-                operation,
-                cooldown: cooldownMs,
-                rateLimitSnapshot,
-            });
-            throw createRateLimitExceededException({
-                operation,
-                retryAfterMs: cooldownMs,
-                rateLimit: rateLimitSnapshot ? toCooldownRateLimit(rateLimitSnapshot, cooldownMs) : undefined,
-            });
-        }
+        await throwIfOperationCooldownActive(operation, { logger, redis });
+        let waitedForSharedCooldown = false;
         const softCooldownMs = await RedisCooldown.getRemainingMs(STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX });
         if (softCooldownMs > 0) {
             logger.info('Delaying stream request due to active soft rate-limit cooldown', {
@@ -72,6 +75,7 @@ export async function executeWithRateLimitHandling(execute, operation, context,
                 cooldown: softCooldownMs,
             });
             await sleep(softCooldownMs);
+            waitedForSharedCooldown = true;
         }
         const budgetCooldownMs = await RedisCooldown.getRemainingMs(STREAM_BUDGET_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX });
         if (budgetCooldownMs > 0) {
@@ -85,11 +89,15 @@ export async function executeWithRateLimitHandling(execute, operation, context,
                 if (waitMs <= 0 || totalBudgetWaitMs >= BUDGET_DELAY_MAX_MS) {
                     break;
                 }
-                const chunkMs = Math.min(waitMs, BUDGET_COOLDOWN_SLEEP_CHUNK_MS);
+                const chunkMs = Math.min(waitMs, BUDGET_COOLDOWN_SLEEP_CHUNK_MS, BUDGET_DELAY_MAX_MS - totalBudgetWaitMs);
                 await sleep(chunkMs);
                 totalBudgetWaitMs += chunkMs;
+                waitedForSharedCooldown = true;
             }
         }
+        if (waitedForSharedCooldown) {
+            await throwIfOperationCooldownActive(operation, { logger, redis });
+        }
     }
     for (;;) {
         try {

package/dist-es/streamRateLimitHandlingProxy/helpers/headerUtils.js

@@ -1,3 +1,5 @@
+const EPOCH_SECONDS_PAST_SKEW_SECONDS = 60;
+const EPOCH_SECONDS_FUTURE_SKEW_SECONDS = 24 * 60 * 60;
 export function getHeaderCaseInsensitive(headers, key) {
     if (!headers) {
         return;
@@ -26,9 +28,15 @@ export function parseHeaderNumber(headers, key) {
     }
 }
 export function normalizeResetToEpochMs(reset) {
-    if (reset < 10000)
-        return Date.now() + Math.round(reset * 1000);
-    if (reset < 10000000000)
+    const nowMs = Date.now();
+    if (!Number.isFinite(reset)) {
+        return nowMs;
+    }
+    if (reset >= 10000000000)
+        return Math.round(reset);
+    const nowSeconds = nowMs / 1000;
+    const looksLikeEpochSeconds = reset >= nowSeconds - EPOCH_SECONDS_PAST_SKEW_SECONDS && reset <= nowSeconds + EPOCH_SECONDS_FUTURE_SKEW_SECONDS;
+    if (looksLikeEpochSeconds)
         return Math.round(reset * 1000);
-    return Math.round(reset);
+    return nowMs + Math.round(reset * 1000);
 }

package/dist-es/streamRateLimitHandlingProxy/helpers/processStreamBudgetHeaders.js

@@ -16,7 +16,7 @@ function isBudgetThresholdReached(limitMs, remainingMs, usedMs) {
         return true;
     }
     if (typeof remainingMs === 'number') {
-        const remainingThreshold = Math.ceil((1 - BUDGET_THRESHOLD) * limitMs);
+        const remainingThreshold = (1 - BUDGET_THRESHOLD) * limitMs;
         return remainingMs <= remainingThreshold;
     }
     return false;
@@ -42,7 +42,7 @@ export async function processStreamBudgetHeaders(headers, context) {
     if (limitMs === undefined && remainingMs === undefined && usedMs === undefined) {
         return;
     }
-    if (typeof limitMs !== 'number' || !Number.isFinite(limitMs)) {
+    if (typeof limitMs !== 'number' || !Number.isFinite(limitMs) || limitMs <= 0) {
         return;
     }
     const usage = getBudgetUsage(limitMs, remainingMs, usedMs);

package/dist-es/streamRateLimitHandlingProxy/helpers/processStreamRateLimitHeaders.js

@@ -7,9 +7,6 @@ function computeSoftThrottleUsage(limit, remaining) {
     }
     return Math.max(0, 1 - remaining / limit);
 }
-function toUsagePercent(usage) {
-    return Math.round(usage * 10000) / 100;
-}
 function computeSoftThrottleDelayMs(limit, remaining) {
     const usage = computeSoftThrottleUsage(limit, remaining);
     if (usage >= SOFT_THROTTLE_USAGE_HIGH) {

package/dist-es/streamRateLimitHandlingProxy/helpers/registerStreamInterceptors.js

@@ -32,23 +32,29 @@ export function registerStreamInterceptors(stream, context) {
         return;
     }
     attachedInterceptors.add(axiosInstance);
-    axiosInstance.interceptors.response.use(async (response) => {
-        try {
-            await processStreamBudgetHeaders(response?.headers, context);
-            await processStreamRateLimitHeaders(response?.headers, context);
-        }
-        catch (error) {
-            logger.warn('Failed to process Stream response headers in interceptor', { error });
-        }
-        return response;
-    }, async (error) => {
-        try {
-            await processStreamBudgetHeaders(error?.response?.headers, context);
-            await processStreamRateLimitHeaders(error?.response?.headers, context);
-        }
-        catch (interceptorError) {
-            logger.warn('Failed to process Stream error headers in interceptor', { error: interceptorError });
-        }
-        return Promise.reject(error);
-    });
+    try {
+        axiosInstance.interceptors.response.use(async (response) => {
+            try {
+                await processStreamBudgetHeaders(response?.headers, context);
+                await processStreamRateLimitHeaders(response?.headers, context);
+            }
+            catch (error) {
+                logger.warn('Failed to process Stream response headers in interceptor', { error });
+            }
+            return response;
+        }, async (error) => {
+            try {
+                await processStreamBudgetHeaders(error?.response?.headers, context);
+                await processStreamRateLimitHeaders(error?.response?.headers, context);
+            }
+            catch (interceptorError) {
+                logger.warn('Failed to process Stream error headers in interceptor', { error: interceptorError });
+            }
+            return Promise.reject(error);
+        });
+    }
+    catch (error) {
+        attachedInterceptors.delete(axiosInstance);
+        logger.warn('Failed to register Stream response interceptors', { error });
+    }
 }

package/dist-types/index.d.ts

@@ -1,4 +1,4 @@
 export * from './normalization';
-export * from './streamRateLimitHandlingProxy';
 export * from './stream';
+export * from './streamRateLimitHandlingProxy';
 export * from './types';

package/dist-types/streamRateLimitHandlingProxy/constants.d.ts

@@ -1,6 +1,5 @@
 import { StreamRateLimitRetryOptions } from './types';
 export { CHANNEL_METHOD_NAMES, CHANNEL_SYNC_METHOD_NAMES, CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES, STREAM_CHANNEL_RESULT_METHOD_NAMES, STREAM_METHOD_NAMES, STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES, STREAM_SYNC_METHOD_NAMES, } from './generatedMethodNames';
-export declare const DEFAULT_MAX_DELAY_MS = 5000;
 export declare const DEFAULT_RETRY_AFTER_MS = 10000;
 export declare const DEFAULT_JITTER_MS = 150;
 export declare const RETRY_AFTER_BUFFER_MS = 1000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wildix/xbees-conversations-utils",
-  "version": "1.1.92",
+  "version": "1.2.0",
   "description": "",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",