@wildix/xbees-conversations-client 1.2.10 → 1.2.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist-cjs/ConversationsClient.js +91 -70
  2. package/dist-cjs/runtimeConfig.browser.js +1 -1
  3. package/dist-cjs/runtimeConfig.js +1 -1
  4. package/dist-es/ConversationsClient.js +91 -70
  5. package/dist-es/runtimeConfig.browser.js +1 -1
  6. package/dist-es/runtimeConfig.js +1 -1
  7. package/package.json +1 -1
package/dist-cjs/ConversationsClient.js CHANGED
@@ -9,6 +9,61 @@ const middleware_retry_1 = require("@smithy/middleware-retry");
9
9
  const smithy_client_1 = require("@smithy/smithy-client");
10
10
  Object.defineProperty(exports, "__Client", { enumerable: true, get: function () { return smithy_client_1.Client; } });
11
11
  const smithy_utils_1 = require("@wildix/smithy-utils");
12
+ const DEFAULT_429_RETRY_DELAY_MS = 1000;
13
+ const parseRetryDelayMs = (rawValue) => {
14
+ if (typeof rawValue === "number" && Number.isFinite(rawValue)) {
15
+ if (rawValue >= 1000) {
16
+ return Math.max(0, Math.round(rawValue));
17
+ }
18
+ return Math.max(0, Math.round(rawValue * 1000));
19
+ }
20
+ if (typeof rawValue !== "string") {
21
+ return undefined;
22
+ }
23
+ const numeric = Number(rawValue);
24
+ if (!Number.isNaN(numeric)) {
25
+ if (numeric >= 1000) {
26
+ return Math.max(0, Math.round(numeric));
27
+ }
28
+ return Math.max(0, Math.round(numeric * 1000));
29
+ }
30
+ const parsedDateMs = Date.parse(rawValue);
31
+ if (!Number.isNaN(parsedDateMs)) {
32
+ return Math.max(0, parsedDateMs - Date.now());
33
+ }
34
+ return undefined;
35
+ };
36
+ const getHeaderCaseInsensitive = (headers, ...names) => {
37
+ if (!headers) {
38
+ return undefined;
39
+ }
40
+ const normalizedNames = names.map((name) => name.toLowerCase());
41
+ for (const [key, value] of Object.entries(headers)) {
42
+ if (normalizedNames.includes(key.toLowerCase())) {
43
+ return value;
44
+ }
45
+ }
46
+ return undefined;
47
+ };
48
+ const get429RetryDelayMs = (error) => {
49
+ const headers = error?.$response?.headers;
50
+ const retryAfter = getHeaderCaseInsensitive(headers, "retry-after");
51
+ const rateLimitReset = getHeaderCaseInsensitive(headers, "x-ratelimit-reset", "ratelimit-reset", "rateLimitReset");
52
+ const retryAfterFromError = error?.retryAfter;
53
+ const delayFromRetryAfter = parseRetryDelayMs(retryAfter);
54
+ if (typeof delayFromRetryAfter === "number") {
55
+ return delayFromRetryAfter;
56
+ }
57
+ const delayFromReset = parseRetryDelayMs(rateLimitReset);
58
+ if (typeof delayFromReset === "number") {
59
+ return delayFromReset;
60
+ }
61
+ const delayFromError = parseRetryDelayMs(retryAfterFromError);
62
+ if (typeof delayFromError === "number") {
63
+ return delayFromError;
64
+ }
65
+ return DEFAULT_429_RETRY_DELAY_MS;
66
+ };
12
67
  class ConversationsClient extends smithy_client_1.Client {
13
68
  config;
14
69
  constructor(...[configuration]) {
@@ -32,51 +87,43 @@ class ConversationsClient extends smithy_client_1.Client {
32
87
  this.middlewareStack.add(smithy_utils_1.authorizationMiddleware.bind(this, configuration.token), { step: "build" });
33
88
  this.middlewareStack.use((0, middleware_user_agent_1.getUserAgentPlugin)(this.config));
34
89
  this.middlewareStack.use((0, middleware_retry_1.getRetryPlugin)(this.config));
35
- this.middlewareStack.add((next) => async (args) => {
36
- try {
37
- return await next(args);
38
- }
39
- catch (error) {
40
- const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
41
- const headers = error?.$response?.headers;
42
- if (statusCode === 429 && headers) {
43
- const headerEntries = Object.entries(headers);
44
- const getHeaderWithKey = (name) => {
45
- const normalizedName = name.toLowerCase();
46
- for (const [key, value] of headerEntries) {
47
- if (key.toLowerCase() === normalizedName && (typeof value === "string" || typeof value === "number")) {
48
- return [key, value];
49
- }
50
- }
51
- return undefined;
52
- };
53
- const retryAfterHeader = getHeaderWithKey("retry-after");
54
- if (retryAfterHeader) {
55
- const [retryAfterKey, retryAfterValueRaw] = retryAfterHeader;
56
- const retryAfterNumeric = Number(retryAfterValueRaw);
57
- if (!Number.isNaN(retryAfterNumeric) && retryAfterNumeric >= 1000) {
58
- const normalizedRetryAfterValue = new Date(Date.now() + retryAfterNumeric).toUTCString();
59
- headers[retryAfterKey] = normalizedRetryAfterValue;
60
- if (configuration?.retryLogging) {
61
- console.warn(`[ConversationsClient] Normalized retry-after header from ${String(retryAfterValueRaw)} to ${normalizedRetryAfterValue}`);
62
- }
63
- }
90
+ this.middlewareStack.add((next, context) => async (args) => {
91
+ const retryOn429 = configuration?.retryOn429 ?? true;
92
+ const maxAttempts = await this.config.maxAttempts();
93
+ let customAttempt = 0;
94
+ for (;;) {
95
+ customAttempt += 1;
96
+ context.__xbsCustom429Attempt = customAttempt;
97
+ context.__xbsCustom429MaxAttempts = maxAttempts;
98
+ try {
99
+ return await next(args);
100
+ }
101
+ catch (error) {
102
+ const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
103
+ if (!retryOn429 || statusCode !== 429 || customAttempt >= maxAttempts) {
104
+ throw error;
105
+ }
106
+ const retryDelayMs = get429RetryDelayMs(error);
107
+ if (configuration?.retryLogging) {
108
+ console.warn(`[ConversationsClient] Custom 429 retry scheduling: attempt ${customAttempt}/${maxAttempts}, delayMs=${retryDelayMs}, nextAt=${new Date(Date.now() + retryDelayMs).toISOString()}`);
64
109
  }
110
+ await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
65
111
  }
66
- throw error;
67
112
  }
68
113
  }, {
69
- name: "retryAfterHeaderNormalizationMiddleware",
70
- step: "finalizeRequest",
71
- priority: "low",
114
+ name: "custom429RetryMiddleware",
115
+ step: "deserialize",
116
+ priority: "high",
72
117
  });
73
118
  if (configuration?.retryLogging) {
74
- this.middlewareStack.add((next) => async (args) => {
119
+ this.middlewareStack.add((next, context) => async (args) => {
75
120
  const request = args.request;
76
121
  const attemptHeader = request?.headers?.["amz-sdk-request"] ?? request?.headers?.["x-amz-sdk-request"];
77
122
  const attemptMatch = typeof attemptHeader === "string" ? attemptHeader.match(/attempt=(\d+)/) : null;
78
- const attempt = attemptMatch ? Number(attemptMatch[1]) : 1;
79
- const maxAttempts = await this.config.maxAttempts();
123
+ const customAttempt = Number(context.__xbsCustom429Attempt) || undefined;
124
+ const customMaxAttempts = Number(context.__xbsCustom429MaxAttempts) || undefined;
125
+ const attempt = customAttempt ?? (attemptMatch ? Number(attemptMatch[1]) : 1);
126
+ const maxAttempts = customMaxAttempts ?? await this.config.maxAttempts();
80
127
  const startedAt = new Date().toISOString();
81
128
  if (attempt > 1) {
82
129
  console.warn(`[ConversationsClient] Retry attempt ${attempt}/${maxAttempts} started at ${startedAt}`);
@@ -89,47 +136,21 @@ class ConversationsClient extends smithy_client_1.Client {
89
136
  }
90
137
  catch (error) {
91
138
  const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
92
- const willRetry = attempt < maxAttempts && this.config.retryDecider(error);
139
+ const retryOn429 = configuration?.retryOn429 ?? true;
140
+ const willRetry = statusCode === 429
141
+ ? retryOn429 && attempt < maxAttempts
142
+ : attempt < maxAttempts && this.config.retryDecider(error);
93
143
  const responseHeaders = (error?.$response?.headers ?? {});
94
- const headerEntries = Object.entries(responseHeaders);
95
- const getHeader = (...names) => {
96
- const normalizedNames = names.map((name) => name.toLowerCase());
97
- for (const [key, value] of headerEntries) {
98
- if (normalizedNames.includes(key.toLowerCase())) {
99
- return value;
100
- }
101
- }
102
- return undefined;
103
- };
144
+ const getHeader = (...names) => getHeaderCaseInsensitive(responseHeaders, ...names);
104
145
  const retryAfterRaw = getHeader("retry-after");
105
146
  const rateLimitResetRaw = getHeader("x-ratelimit-reset", "ratelimit-reset", "rateLimitReset");
106
147
  const rateLimitRaw = getHeader("x-ratelimit-limit", "ratelimit-limit", "rateLimit");
107
148
  const rateLimitRemainingRaw = getHeader("x-ratelimit-remaining", "ratelimit-remaining", "rateLimitRemaining");
108
- let retryAfterDelayMs;
109
- if (retryAfterRaw !== undefined) {
110
- const retryAfterNumeric = Number(retryAfterRaw);
111
- if (!Number.isNaN(retryAfterNumeric)) {
112
- retryAfterDelayMs = retryAfterNumeric >= 1000 ? retryAfterNumeric : retryAfterNumeric * 1000;
113
- }
114
- else {
115
- retryAfterDelayMs = new Date(retryAfterRaw).getTime() - Date.now();
116
- }
117
- }
118
- let rateLimitResetDelayMs;
119
- if (rateLimitResetRaw !== undefined) {
120
- const resetValue = Number(rateLimitResetRaw);
121
- if (!Number.isNaN(resetValue)) {
122
- if (resetValue > 1000000000) {
123
- rateLimitResetDelayMs = (resetValue * 1000) - Date.now();
124
- }
125
- else {
126
- rateLimitResetDelayMs = resetValue >= 1000 ? resetValue : resetValue * 1000;
127
- }
128
- }
129
- }
149
+ const retryAfterDelayMs = parseRetryDelayMs(retryAfterRaw);
150
+ const rateLimitResetDelayMs = parseRetryDelayMs(rateLimitResetRaw);
130
151
  if (willRetry) {
131
152
  console.warn(`[ConversationsClient] Retry decision: will retry after attempt ${attempt}/${maxAttempts} (status=${statusCode ?? "unknown"}, time=${new Date().toISOString()})`);
132
- console.warn(`[ConversationsClient] Retry headers: retry-after=${retryAfterRaw ?? "n/a"}, x-ratelimit-reset=${rateLimitResetRaw ?? "n/a"}, x-ratelimit-limit=${rateLimitRaw ?? "n/a"}, x-ratelimit-remaining=${rateLimitRemainingRaw ?? "n/a"}`);
153
+ console.warn(`[ConversationsClient] Retry headers: retry-after=${String(retryAfterRaw ?? "n/a")}, x-ratelimit-reset=${String(rateLimitResetRaw ?? "n/a")}, x-ratelimit-limit=${String(rateLimitRaw ?? "n/a")}, x-ratelimit-remaining=${String(rateLimitRemainingRaw ?? "n/a")}`);
133
154
  console.warn(`[ConversationsClient] Parsed retry timing: retryAfterDelayMs=${retryAfterDelayMs ?? "n/a"}, rateLimitResetDelayMs=${rateLimitResetDelayMs ?? "n/a"}`);
134
155
  }
135
156
  else {
package/dist-cjs/runtimeConfig.browser.js CHANGED
@@ -27,7 +27,7 @@ const getRuntimeConfig = (config) => {
27
27
  retryDecider: config?.retryDecider ?? ((error) => {
28
28
  const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
29
29
  if (statusCode === 429) {
30
- return Boolean(config?.retryOn429 ?? true);
30
+ return false;
31
31
  }
32
32
  return Boolean(error?.$retryable?.throttling
33
33
  || error?.$retryable?.retryable
package/dist-cjs/runtimeConfig.js CHANGED
@@ -31,7 +31,7 @@ const getRuntimeConfig = (config) => {
31
31
  retryDecider: config?.retryDecider ?? ((error) => {
32
32
  const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
33
33
  if (statusCode === 429) {
34
- return Boolean(config?.retryOn429 ?? true);
34
+ return false;
35
35
  }
36
36
  return Boolean(error?.$retryable?.throttling
37
37
  || error?.$retryable?.retryable
package/dist-es/ConversationsClient.js CHANGED
@@ -6,6 +6,61 @@ import { getRetryPlugin, resolveRetryConfig, } from "@smithy/middleware-retry";
6
6
  import { Client as __Client, } from "@smithy/smithy-client";
7
7
  import { authorizationMiddleware } from '@wildix/smithy-utils';
8
8
  export { __Client };
9
+ const DEFAULT_429_RETRY_DELAY_MS = 1000;
10
+ const parseRetryDelayMs = (rawValue) => {
11
+ if (typeof rawValue === "number" && Number.isFinite(rawValue)) {
12
+ if (rawValue >= 1000) {
13
+ return Math.max(0, Math.round(rawValue));
14
+ }
15
+ return Math.max(0, Math.round(rawValue * 1000));
16
+ }
17
+ if (typeof rawValue !== "string") {
18
+ return undefined;
19
+ }
20
+ const numeric = Number(rawValue);
21
+ if (!Number.isNaN(numeric)) {
22
+ if (numeric >= 1000) {
23
+ return Math.max(0, Math.round(numeric));
24
+ }
25
+ return Math.max(0, Math.round(numeric * 1000));
26
+ }
27
+ const parsedDateMs = Date.parse(rawValue);
28
+ if (!Number.isNaN(parsedDateMs)) {
29
+ return Math.max(0, parsedDateMs - Date.now());
30
+ }
31
+ return undefined;
32
+ };
33
+ const getHeaderCaseInsensitive = (headers, ...names) => {
34
+ if (!headers) {
35
+ return undefined;
36
+ }
37
+ const normalizedNames = names.map((name) => name.toLowerCase());
38
+ for (const [key, value] of Object.entries(headers)) {
39
+ if (normalizedNames.includes(key.toLowerCase())) {
40
+ return value;
41
+ }
42
+ }
43
+ return undefined;
44
+ };
45
+ const get429RetryDelayMs = (error) => {
46
+ const headers = error?.$response?.headers;
47
+ const retryAfter = getHeaderCaseInsensitive(headers, "retry-after");
48
+ const rateLimitReset = getHeaderCaseInsensitive(headers, "x-ratelimit-reset", "ratelimit-reset", "rateLimitReset");
49
+ const retryAfterFromError = error?.retryAfter;
50
+ const delayFromRetryAfter = parseRetryDelayMs(retryAfter);
51
+ if (typeof delayFromRetryAfter === "number") {
52
+ return delayFromRetryAfter;
53
+ }
54
+ const delayFromReset = parseRetryDelayMs(rateLimitReset);
55
+ if (typeof delayFromReset === "number") {
56
+ return delayFromReset;
57
+ }
58
+ const delayFromError = parseRetryDelayMs(retryAfterFromError);
59
+ if (typeof delayFromError === "number") {
60
+ return delayFromError;
61
+ }
62
+ return DEFAULT_429_RETRY_DELAY_MS;
63
+ };
9
64
  export class ConversationsClient extends __Client {
10
65
  config;
11
66
  constructor(...[configuration]) {
@@ -29,51 +84,43 @@ export class ConversationsClient extends __Client {
29
84
  this.middlewareStack.add(authorizationMiddleware.bind(this, configuration.token), { step: "build" });
30
85
  this.middlewareStack.use(getUserAgentPlugin(this.config));
31
86
  this.middlewareStack.use(getRetryPlugin(this.config));
32
- this.middlewareStack.add((next) => async (args) => {
33
- try {
34
- return await next(args);
35
- }
36
- catch (error) {
37
- const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
38
- const headers = error?.$response?.headers;
39
- if (statusCode === 429 && headers) {
40
- const headerEntries = Object.entries(headers);
41
- const getHeaderWithKey = (name) => {
42
- const normalizedName = name.toLowerCase();
43
- for (const [key, value] of headerEntries) {
44
- if (key.toLowerCase() === normalizedName && (typeof value === "string" || typeof value === "number")) {
45
- return [key, value];
46
- }
47
- }
48
- return undefined;
49
- };
50
- const retryAfterHeader = getHeaderWithKey("retry-after");
51
- if (retryAfterHeader) {
52
- const [retryAfterKey, retryAfterValueRaw] = retryAfterHeader;
53
- const retryAfterNumeric = Number(retryAfterValueRaw);
54
- if (!Number.isNaN(retryAfterNumeric) && retryAfterNumeric >= 1000) {
55
- const normalizedRetryAfterValue = new Date(Date.now() + retryAfterNumeric).toUTCString();
56
- headers[retryAfterKey] = normalizedRetryAfterValue;
57
- if (configuration?.retryLogging) {
58
- console.warn(`[ConversationsClient] Normalized retry-after header from ${String(retryAfterValueRaw)} to ${normalizedRetryAfterValue}`);
59
- }
60
- }
87
+ this.middlewareStack.add((next, context) => async (args) => {
88
+ const retryOn429 = configuration?.retryOn429 ?? true;
89
+ const maxAttempts = await this.config.maxAttempts();
90
+ let customAttempt = 0;
91
+ for (;;) {
92
+ customAttempt += 1;
93
+ context.__xbsCustom429Attempt = customAttempt;
94
+ context.__xbsCustom429MaxAttempts = maxAttempts;
95
+ try {
96
+ return await next(args);
97
+ }
98
+ catch (error) {
99
+ const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
100
+ if (!retryOn429 || statusCode !== 429 || customAttempt >= maxAttempts) {
101
+ throw error;
102
+ }
103
+ const retryDelayMs = get429RetryDelayMs(error);
104
+ if (configuration?.retryLogging) {
105
+ console.warn(`[ConversationsClient] Custom 429 retry scheduling: attempt ${customAttempt}/${maxAttempts}, delayMs=${retryDelayMs}, nextAt=${new Date(Date.now() + retryDelayMs).toISOString()}`);
61
106
  }
107
+ await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
62
108
  }
63
- throw error;
64
109
  }
65
110
  }, {
66
- name: "retryAfterHeaderNormalizationMiddleware",
67
- step: "finalizeRequest",
68
- priority: "low",
111
+ name: "custom429RetryMiddleware",
112
+ step: "deserialize",
113
+ priority: "high",
69
114
  });
70
115
  if (configuration?.retryLogging) {
71
- this.middlewareStack.add((next) => async (args) => {
116
+ this.middlewareStack.add((next, context) => async (args) => {
72
117
  const request = args.request;
73
118
  const attemptHeader = request?.headers?.["amz-sdk-request"] ?? request?.headers?.["x-amz-sdk-request"];
74
119
  const attemptMatch = typeof attemptHeader === "string" ? attemptHeader.match(/attempt=(\d+)/) : null;
75
- const attempt = attemptMatch ? Number(attemptMatch[1]) : 1;
76
- const maxAttempts = await this.config.maxAttempts();
120
+ const customAttempt = Number(context.__xbsCustom429Attempt) || undefined;
121
+ const customMaxAttempts = Number(context.__xbsCustom429MaxAttempts) || undefined;
122
+ const attempt = customAttempt ?? (attemptMatch ? Number(attemptMatch[1]) : 1);
123
+ const maxAttempts = customMaxAttempts ?? await this.config.maxAttempts();
77
124
  const startedAt = new Date().toISOString();
78
125
  if (attempt > 1) {
79
126
  console.warn(`[ConversationsClient] Retry attempt ${attempt}/${maxAttempts} started at ${startedAt}`);
@@ -86,47 +133,21 @@ export class ConversationsClient extends __Client {
86
133
  }
87
134
  catch (error) {
88
135
  const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
89
- const willRetry = attempt < maxAttempts && this.config.retryDecider(error);
136
+ const retryOn429 = configuration?.retryOn429 ?? true;
137
+ const willRetry = statusCode === 429
138
+ ? retryOn429 && attempt < maxAttempts
139
+ : attempt < maxAttempts && this.config.retryDecider(error);
90
140
  const responseHeaders = (error?.$response?.headers ?? {});
91
- const headerEntries = Object.entries(responseHeaders);
92
- const getHeader = (...names) => {
93
- const normalizedNames = names.map((name) => name.toLowerCase());
94
- for (const [key, value] of headerEntries) {
95
- if (normalizedNames.includes(key.toLowerCase())) {
96
- return value;
97
- }
98
- }
99
- return undefined;
100
- };
141
+ const getHeader = (...names) => getHeaderCaseInsensitive(responseHeaders, ...names);
101
142
  const retryAfterRaw = getHeader("retry-after");
102
143
  const rateLimitResetRaw = getHeader("x-ratelimit-reset", "ratelimit-reset", "rateLimitReset");
103
144
  const rateLimitRaw = getHeader("x-ratelimit-limit", "ratelimit-limit", "rateLimit");
104
145
  const rateLimitRemainingRaw = getHeader("x-ratelimit-remaining", "ratelimit-remaining", "rateLimitRemaining");
105
- let retryAfterDelayMs;
106
- if (retryAfterRaw !== undefined) {
107
- const retryAfterNumeric = Number(retryAfterRaw);
108
- if (!Number.isNaN(retryAfterNumeric)) {
109
- retryAfterDelayMs = retryAfterNumeric >= 1000 ? retryAfterNumeric : retryAfterNumeric * 1000;
110
- }
111
- else {
112
- retryAfterDelayMs = new Date(retryAfterRaw).getTime() - Date.now();
113
- }
114
- }
115
- let rateLimitResetDelayMs;
116
- if (rateLimitResetRaw !== undefined) {
117
- const resetValue = Number(rateLimitResetRaw);
118
- if (!Number.isNaN(resetValue)) {
119
- if (resetValue > 1000000000) {
120
- rateLimitResetDelayMs = (resetValue * 1000) - Date.now();
121
- }
122
- else {
123
- rateLimitResetDelayMs = resetValue >= 1000 ? resetValue : resetValue * 1000;
124
- }
125
- }
126
- }
146
+ const retryAfterDelayMs = parseRetryDelayMs(retryAfterRaw);
147
+ const rateLimitResetDelayMs = parseRetryDelayMs(rateLimitResetRaw);
127
148
  if (willRetry) {
128
149
  console.warn(`[ConversationsClient] Retry decision: will retry after attempt ${attempt}/${maxAttempts} (status=${statusCode ?? "unknown"}, time=${new Date().toISOString()})`);
129
- console.warn(`[ConversationsClient] Retry headers: retry-after=${retryAfterRaw ?? "n/a"}, x-ratelimit-reset=${rateLimitResetRaw ?? "n/a"}, x-ratelimit-limit=${rateLimitRaw ?? "n/a"}, x-ratelimit-remaining=${rateLimitRemainingRaw ?? "n/a"}`);
150
+ console.warn(`[ConversationsClient] Retry headers: retry-after=${String(retryAfterRaw ?? "n/a")}, x-ratelimit-reset=${String(rateLimitResetRaw ?? "n/a")}, x-ratelimit-limit=${String(rateLimitRaw ?? "n/a")}, x-ratelimit-remaining=${String(rateLimitRemainingRaw ?? "n/a")}`);
130
151
  console.warn(`[ConversationsClient] Parsed retry timing: retryAfterDelayMs=${retryAfterDelayMs ?? "n/a"}, rateLimitResetDelayMs=${rateLimitResetDelayMs ?? "n/a"}`);
131
152
  }
132
153
  else {
package/dist-es/runtimeConfig.browser.js CHANGED
@@ -23,7 +23,7 @@ export const getRuntimeConfig = (config) => {
23
23
  retryDecider: config?.retryDecider ?? ((error) => {
24
24
  const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
25
25
  if (statusCode === 429) {
26
- return Boolean(config?.retryOn429 ?? true);
26
+ return false;
27
27
  }
28
28
  return Boolean(error?.$retryable?.throttling
29
29
  || error?.$retryable?.retryable
package/dist-es/runtimeConfig.js CHANGED
@@ -27,7 +27,7 @@ export const getRuntimeConfig = (config) => {
27
27
  retryDecider: config?.retryDecider ?? ((error) => {
28
28
  const statusCode = error?.$metadata?.httpStatusCode ?? error?.$response?.statusCode;
29
29
  if (statusCode === 429) {
30
- return Boolean(config?.retryOn429 ?? true);
30
+ return false;
31
31
  }
32
32
  return Boolean(error?.$retryable?.throttling
33
33
  || error?.$retryable?.retryable
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@wildix/xbees-conversations-client",
3
3
  "description": "@wildix/xbees-conversations-client client",
4
- "version": "1.2.10",
4
+ "version": "1.2.11",
5
5
  "scripts": {
6
6
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
7
7
  "build:cjs": "tsc -p tsconfig.cjs.json",