@friggframework/core 2.0.0--canary.658.93c8e07.0 → 2.0.0--canary.656.4fb07b4.0

package/CLAUDE.md

@@ -370,49 +370,11 @@ class MyIntegration extends IntegrationBase {
 - `BasicAuthRequester` - Basic authentication
 
 **Rate limits** (ADR-049): an API module declares `static rateLimit` on its
-`Requester` subclass. For a throttled response the Requester looks for a hint
-in this order:
-
-| Step | Source |
-|---|---|
-| 1 | `classify({ status, headers, body })` of the module. It recognises a limit that is not a plain 429 (a 403 limit code, a `policyName` in the body) and may name only a `reason` |
-| 2 | The header parsers in `parsers` order. Default: `retryAfter`, `resetHeaders`, `ietf` |
-| 3 | The static policy: `minRetryAfterMs`, or the `perMs` of the window named by the `reason` |
-| 4 | The fixed `backOff` ladder (1, 3, 10, 30, 60, 180 s) |
-
-- A 429 with no hint from steps 1 to 3 keeps today's ladder: the same calls,
-  the same delays, then a plain `FetchError`. Nothing budgets it. A response
-  that `classify` names as a limit but that has no time follows the same
-  ladder, and the last error is a `FetchError` flagged `isRateLimited` with
-  the `reason`, so the queue worker does not halt it.
-- With a hint, the wait is `max(hint, minRetryAfterMs, 1 s)` plus at most 10 %
-  jitter. The total sleep of one request is capped at `maxInProcessWaitMs`
-  (default 5 minutes) and at the time left in the invocation less one request
-  timeout (`remainingInvocationMs()`).
-- A wait that does not fit throws `RateLimitError` (`isRateLimited`, `retryAt`,
-  `waitMs`, `reason`, `policy`, `source`, `module`, `scopeKey`). The queue
-  worker does not halt it, whatever its status.
-- `Retry-After` is read on a 429 only. Another status counts only when
-  `classify` recognises it. A 5xx keeps the 5xx ladder.
-- `maxInProcessWaitMs: 0` turns off sleeping: every hinted wait throws.
-- A module that does not use the Requester (for example one on jsforce) calls
-  `classifyRateLimit(policy, { status, headers, body })` around its own client
-  and throws `RateLimitError` itself.
-
-```javascript
-class Api extends OAuth2Requester {
-    static rateLimit = {
-        scope: 'entity',
-        minRetryAfterMs: 1_000,
-        classify({ status, body }) {
-            if (status === 403 && body?.code === 'DAILY_LIMIT') {
-                return { reason: 'daily', waitMs: 60 * 60_000 };
-            }
-            return null;
-        },
-    };
-}
-```
+`Requester` subclass. A hinted wait (from `classify()`, the header parsers or
+the static policy) sleeps within a budget, or throws `RateLimitError`
+(`isRateLimited`, `retryAt`) when it does not fit. A 429 with no hint keeps the
+fixed `backOff` ladder. See
+[Rate Limits](../../docs/reference/api-module-definition-and-functions.md#rate-limits-static-ratelimit).
 
 **Module Factory**:
 - `ModuleFactory` - Creates and configures API module instances
@@ -568,53 +530,6 @@ if (!userId) {
 }
 ```
 
-**Rate-limit message** (ADR-049): when a wait is too long to sleep, the
-Requester tells its delegate (`RATE_LIMITED`, with the `RateLimitError`) and
-then throws. The notification takes the path of `CREDENTIAL_INVALIDATED`:
-Requester, `Module`, `IntegrationBase`.
-
-- The `Module` sends `{ moduleName, reason, retryAt, policy, statusCode, links }`.
-  `links` is `static rateLimit.userHints[reason].links`, or `[]`. The message,
-  url, body and headers of the error are never sent: the message reaches end
-  users.
-- `IntegrationBase` writes one `WARN` (`integration.<name>.rate_limited`), and
-  `RecordRateLimitMessage` appends one item to the stored `warnings`. It
-  changes no status. A rate limit is not an `ERROR`, and an `ERROR` status
-  makes the queue worker drop every webhook.
-- A report for the same module whose reset time is within 60 s of a stored one
-  is skipped. The check reads the stored `warnings` with
-  `findIntegrationMessages`, not `this.messages`, which is per instance and
-  empty on Postgres. It is a read then a write, so workers that report at the
-  same instant can still store a few copies.
-- Every hop is best effort. A failure is logged, and the caller still gets the
-  `RateLimitError`.
-
-```javascript
-{
-    title: 'Rate limit reached',
-    message: 'The hubspot API rate limit was reached and resets at 2026-09-28 14:31 UTC.',
-    timestamp: 1790000000000,
-    code: 'RATE_LIMITED',
-    module: 'hubspot',
-    reason: 'daily',
-    retryAt: '2026-09-28T14:30:15.000Z',
-    actions: [
-        { type: 'RETRY_WHEN_READY' },
-        { type: 'LINK', label: 'API usage limits', url: 'https://example.com/limits' },
-    ],
-}
-```
-
-The text is fixed. It holds the module name and the reset time in UTC, rounded
-up to the minute, and nothing from the request.
-`updateIntegrationMessages(id, type, title, body, timestamp)` still works, and
-it also takes one item object, `updateIntegrationMessages(id, type, item)`,
-whose keys are stored as they are. Every call appends.
-`findIntegrationMessages(id, type)` reads the stored items of one type. The
-`messages` of the record from `findIntegrationById` is not filled on Postgres
-and Mongo, because the schema keeps the messages in the `errors`, `warnings`,
-`info` and `logs` columns.
-
 ### 9. Logging System (`/logs`)
 
 **Purpose**: One redacted JSON record per line to stdout (ADR-048). See `docs/guides/LOGGING.md`.

package/core/invocation-deadline.js

@@ -9,11 +9,6 @@ function storage() {
     return globalThis[STORE_KEY];
 }
 
-/**
- * Runs fn with the time the invocation ends, as epoch milliseconds. A nested
- * scope can shorten the deadline and never extend it. A deadline that is not
- * a finite number runs fn with no limit.
- */
 function runWithInvocationDeadline(deadlineAt, fn) {
     if (typeof deadlineAt !== 'number' || !Number.isFinite(deadlineAt)) {
         return fn();
@@ -25,25 +20,20 @@ function runWithInvocationDeadline(deadlineAt, fn) {
     return storage().run(Object.freeze({ deadlineAt: effective }), fn);
 }
 
-/**
- * The end of a Lambda invocation, from its context. Undefined when the
- * context cannot tell.
- */
-function deadlineFromContext(context) {
+function remainingTimeMs(context) {
     try {
         const remaining = context?.getRemainingTimeInMillis?.();
-        return typeof remaining === 'number' && Number.isFinite(remaining)
-            ? Date.now() + remaining
-            : undefined;
-    } catch {
-        return undefined;
+        return typeof remaining === 'number' ? remaining : Infinity;
+    } catch (_) {
+        return Infinity;
     }
 }
 
-/**
- * Milliseconds left in the invocation. Infinity outside a deadline scope
- * (tests, `frigg start`, scripts).
- */
+function deadlineFromContext(context) {
+    const remaining = remainingTimeMs(context);
+    return Number.isFinite(remaining) ? Date.now() + remaining : undefined;
+}
+
 function remainingInvocationMs(now = Date.now()) {
     const store = storage().getStore();
     return store ? Math.max(0, store.deadlineAt - now) : Infinity;
@@ -52,5 +42,6 @@ function remainingInvocationMs(now = Date.now()) {
 module.exports = {
     deadlineFromContext,
     remainingInvocationMs,
+    remainingTimeMs,
     runWithInvocationDeadline,
 };

package/core/invocation-scope.js

@@ -3,6 +3,7 @@ const { summarizeMessageBody } = require('../logs/summarize-event');
 const { flushSinks, hasFlushableSinks } = require('../logs/logger-runtime');
 const {
     deadlineFromContext,
+    remainingTimeMs,
     runWithInvocationDeadline,
 } = require('./invocation-deadline');
 
@@ -115,15 +116,6 @@ function withDeadline(ms, fn) {
     });
 }
 
-function remainingTimeMs(context) {
-    try {
-        const remaining = context?.getRemainingTimeInMillis?.();
-        return typeof remaining === 'number' ? remaining : Infinity;
-    } catch (_) {
-        return Infinity;
-    }
-}
-
 async function flushInvocation({
     telemetry,
     usageRollup,

package/errors/fetch-error.js

@@ -55,15 +55,13 @@ class FetchError extends BaseError {
 
     static async create(options = {}) {
         const { response } = options;
-        const provided = options.responseBody ?? options.body;
-        let responseBody = provided;
-        if (
-            responseBody === undefined &&
-            response &&
-            !response.bodyUsed &&
-            typeof response.text === 'function'
-        ) {
-            responseBody = (await response.text()) || provided;
+        let { responseBody } = options;
+        if (responseBody === undefined || responseBody === null) {
+            const canRead =
+                response &&
+                !response.bodyUsed &&
+                typeof response.text === 'function';
+            responseBody = (canRead && (await response.text())) || options.body;
         }
         const ErrorClass = typeof this === 'function' ? this : FetchError;
         return new ErrorClass({ ...options, responseBody });

package/errors/rate-limit-error.js

@@ -14,10 +14,6 @@ function resolveTiming({ hint, waitMs, now }) {
     return { waitMs: fallbackWaitMs, retryAt: new Date(now + fallbackWaitMs) };
 }
 
-/**
- * A FetchError for a response that said a limit was hit and told us, or the
- * module's policy told us, when to call again. `retryAt` is that time.
- */
 class RateLimitError extends FetchError {
     constructor({
         hint,

package/integrations/integration-base.js

@@ -17,9 +17,6 @@ const {
 const {
     UpdateIntegrationConfig,
 } = require('./use-cases/update-integration-config');
-const {
-    RecordRateLimitMessage,
-} = require('./use-cases/record-rate-limit-message');
 const { validateExtensionBinding } = require('./extension');
 const { getTelemetry } = require('../telemetry/telemetry-runtime');
 const { instrumentHandler } = require('../telemetry/instrument-handler');
@@ -62,9 +59,6 @@ class IntegrationBase {
     updateIntegrationConfig = new UpdateIntegrationConfig({
         integrationRepository: this.integrationRepository,
     });
-    recordRateLimitMessage = new RecordRateLimitMessage({
-        integrationRepository: this.integrationRepository,
-    });
 
     // this.telemetry.count('records.synced', n, { entity: 'contact' })
     telemetry = bindTelemetryContext(getTelemetry(), () =>
@@ -871,9 +865,7 @@ class IntegrationBase {
      * something integration-level needs attention. Today this catches the
      * `CREDENTIAL_INVALIDATED` event Module fires from `markCredentialsInvalid`
      * and flips this integration's status to ERROR so the queue worker
-     * stops processing further webhooks until the user re-authorizes. It also
-     * catches `RATE_LIMITED`, which records one warning for the user and
-     * changes no status: a rate limit is not an error.
+     * stops processing further webhooks until the user re-authorizes.
      *
      * Modules are wired to this delegate in `_appendModules()`, which runs
      * during `setIntegrationRecord()` — this covers every construction path
@@ -916,17 +908,6 @@ class IntegrationBase {
             });
             await this.persistStatus('ENABLED');
         }
-
-        if (delegateString === 'RATE_LIMITED') {
-            const moduleName = object?.moduleName ?? notifier?.name;
-            this.logger.warn('Module reported a rate limit', {
-                eventName: `${this.logger.name}.rate_limited`,
-                moduleName,
-                reason: object?.reason,
-                retryAt: object?.retryAt,
-            });
-            await this._recordRateLimitMessage({ ...object, moduleName });
-        }
     }
 
     /**
@@ -952,23 +933,6 @@ class IntegrationBase {
             });
         }
     }
-
-    /**
-     * Best-effort: the module's request is about to throw a RateLimitError,
-     * and a failed warning must not change that. A rate limit is not an ERROR,
-     * so this never touches the integration status.
-     * @param {Object} payload - The RATE_LIMITED payload of the module.
-     */
-    async _recordRateLimitMessage(payload) {
-        try {
-            await this.recordRateLimitMessage.execute(this.id, payload);
-        } catch (error) {
-            this.logger.error('Failed to record rate limit message', {
-                eventName: `${this.logger.name}.rate_limit_message_record_failed`,
-                error,
-            });
-        }
-    }
 }
 
 module.exports = { IntegrationBase };

package/integrations/repositories/integration-repository-documentdb.js

@@ -14,7 +14,6 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
-const { toMessageItem } = require('./message-item-shared');
 
 class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     constructor() {
@@ -95,7 +94,7 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     async updateIntegrationMessages(
         integrationId,
         messageType,
-        messageTitleOrItem,
+        messageTitle,
         messageBody,
         messageTimestamp
     ) {
@@ -109,12 +108,11 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         }
         const messages = this._extractMessages(existing);
         const list = Array.isArray(messages[messageType]) ? [...messages[messageType]] : [];
-        const item = toMessageItem(
-            messageTitleOrItem,
-            messageBody,
-            messageTimestamp
-        );
-        list.push({ ...item, title: item.title ?? null });
+        list.push({
+            title: messageTitle ?? null,
+            message: messageBody,
+            timestamp: messageTimestamp,
+        });
         const updatedMessages = { ...messages, [messageType]: list };
         await updateOne(
             this.prisma,
@@ -134,23 +132,6 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         return true;
     }
 
-    async findIntegrationMessages(integrationId, messageType) {
-        const objectId = toObjectId(integrationId);
-        if (!objectId) {
-            throw new Error(`Integration ${integrationId} not found`);
-        }
-        const existing = await findOne(this.prisma, 'Integration', {
-            _id: objectId,
-        });
-        if (!existing) {
-            throw new Error(`Integration ${integrationId} not found`);
-        }
-        const messages = this._extractMessages(existing);
-        return Array.isArray(messages[messageType])
-            ? messages[messageType]
-            : [];
-    }
-
     async createIntegration(entities, userId, config) {
         const now = new Date();
         const document = {

package/integrations/repositories/integration-repository-interface.js

@@ -97,43 +97,26 @@ class IntegrationRepositoryInterface {
     }
 
     /**
-     * Append a message to the stored messages of one type. Takes the
-     * positional form (title, body, timestamp) or one message item object,
-     * whose keys are stored as they are.
+     * Update integration messages
      *
      * @param {string|number} integrationId - Integration ID
      * @param {string} messageType - Type of message (errors, warnings, info, logs)
-     * @param {string|Object} messageTitleOrItem - Message title, or the whole message item
-     * @param {string} [messageBody] - Message body (positional form)
-     * @param {Date} [messageTimestamp] - Message timestamp (positional form)
+     * @param {string} messageTitle - Message title
+     * @param {string} messageBody - Message body
+     * @param {Date} messageTimestamp - Message timestamp
      * @returns {Promise<boolean>} Success indicator
      * @abstract
      */
     async updateIntegrationMessages(
         integrationId,
         messageType,
-        messageTitleOrItem,
+        messageTitle,
         messageBody,
         messageTimestamp
     ) {
         throw new Error('Method updateIntegrationMessages must be implemented by subclass');
     }
 
-    /**
-     * Find the stored messages of one type. Reads the stored items, not the
-     * `messages` of an integration record, which some adapters do not fill.
-     *
-     * @param {string|number} integrationId - Integration ID
-     * @param {string} messageType - Type of message (errors, warnings, info, logs)
-     * @returns {Promise<Array>} The stored message items of that type, oldest first
-     * @abstract
-     */
-    async findIntegrationMessages(integrationId, messageType) {
-        throw new Error(
-            'Method findIntegrationMessages must be implemented by subclass'
-        );
-    }
-
     /**
      * Create a new integration
      *

package/integrations/repositories/integration-repository-mongo.js

@@ -3,7 +3,6 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
-const { toMessageItem } = require('./message-item-shared');
 
 /**
  * MongoDB Integration Repository Adapter
@@ -230,15 +229,15 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
      *
      * @param {string} integrationId - Integration ID
      * @param {string} messageType - Type of message (errors, warnings, info, logs)
-     * @param {string|Object} messageTitleOrItem - Message title, or the whole message item
-     * @param {string} [messageBody] - Message body (positional form)
-     * @param {Date} [messageTimestamp] - Message timestamp (positional form)
+     * @param {string} messageTitle - Message title
+     * @param {string} messageBody - Message body
+     * @param {Date} messageTimestamp - Message timestamp
      * @returns {Promise<boolean>} Success indicator
      */
     async updateIntegrationMessages(
         integrationId,
         messageType,
-        messageTitleOrItem,
+        messageTitle,
         messageBody,
         messageTimestamp
     ) {
@@ -252,14 +251,17 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         }
 
         // Parse existing messages (JSON field)
-        const messageArray = Array.isArray(integration[messageType])
-            ? integration[messageType]
+        const messages = integration.messages || {};
+        const messageArray = Array.isArray(messages[messageType])
+            ? messages[messageType]
             : [];
 
         // Add new message
-        messageArray.push(
-            toMessageItem(messageTitleOrItem, messageBody, messageTimestamp)
-        );
+        messageArray.push({
+            title: messageTitle,
+            message: messageBody,
+            timestamp: messageTimestamp,
+        });
 
         // Update messages
         await this.prisma.integration.update({
@@ -272,28 +274,6 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         return true; // Mongoose compatibility
     }
 
-    /**
-     * Find the stored messages of one type
-     *
-     * @param {string} integrationId - Integration ID
-     * @param {string} messageType - Type of message (errors, warnings, info, logs)
-     * @returns {Promise<Array>} The stored message items of that type, oldest first
-     */
-    async findIntegrationMessages(integrationId, messageType) {
-        const integration = await this.prisma.integration.findUnique({
-            where: { id: integrationId },
-            select: { [messageType]: true },
-        });
-
-        if (!integration) {
-            throw new Error(`Integration ${integrationId} not found`);
-        }
-
-        return Array.isArray(integration[messageType])
-            ? integration[messageType]
-            : [];
-    }
-
     /**
      * Find all integrations whose entity set includes the given entity ID.
      *

package/integrations/repositories/integration-repository-postgres.js

@@ -3,7 +3,6 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
-const { toMessageItem } = require('./message-item-shared');
 const { strictIntId } = require('./report-id');
 
 /**
@@ -274,15 +273,15 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
      *
      * @param {string} integrationId - Integration ID (string from application layer)
      * @param {string} messageType - Type of message (errors, warnings, info, logs)
-     * @param {string|Object} messageTitleOrItem - Message title, or the whole message item
-     * @param {string} [messageBody] - Message body (positional form)
-     * @param {Date} [messageTimestamp] - Message timestamp (positional form)
+     * @param {string} messageTitle - Message title
+     * @param {string} messageBody - Message body
+     * @param {Date} messageTimestamp - Message timestamp
      * @returns {Promise<boolean>} Success indicator
      */
     async updateIntegrationMessages(
         integrationId,
         messageType,
-        messageTitleOrItem,
+        messageTitle,
         messageBody,
         messageTimestamp
     ) {
@@ -298,14 +297,17 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         }
 
         // Parse existing messages (JSON field)
-        const messageArray = Array.isArray(integration[messageType])
-            ? integration[messageType]
+        const messages = integration.messages || {};
+        const messageArray = Array.isArray(messages[messageType])
+            ? messages[messageType]
             : [];
 
         // Add new message
-        messageArray.push(
-            toMessageItem(messageTitleOrItem, messageBody, messageTimestamp)
-        );
+        messageArray.push({
+            title: messageTitle,
+            message: messageBody,
+            timestamp: messageTimestamp,
+        });
 
         // Update messages
         await this.prisma.integration.update({
@@ -318,29 +320,6 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         return true; // Mongoose compatibility
     }
 
-    /**
-     * Find the stored messages of one type
-     *
-     * @param {string} integrationId - Integration ID (string from application layer)
-     * @param {string} messageType - Type of message (errors, warnings, info, logs)
-     * @returns {Promise<Array>} The stored message items of that type, oldest first
-     */
-    async findIntegrationMessages(integrationId, messageType) {
-        const intId = this._convertId(integrationId);
-        const integration = await this.prisma.integration.findUnique({
-            where: { id: intId },
-            select: { [messageType]: true },
-        });
-
-        if (!integration) {
-            throw new Error(`Integration ${integrationId} not found`);
-        }
-
-        return Array.isArray(integration[messageType])
-            ? integration[messageType]
-            : [];
-    }
-
     /**
      * Create a new integration
      *

package/integrations/tests/doubles/test-integration-repository.js

@@ -1,6 +1,5 @@
 const { v4: uuid } = require('uuid');
 const { validateConfigPatch } = require('../../repositories/config-patch-shared');
-const { toMessageItem } = require('../../repositories/message-item-shared');
 
 class TestIntegrationRepository {
     constructor() {
@@ -73,30 +72,18 @@ class TestIntegrationRepository {
         return results;
     }
 
-    async updateIntegrationMessages(id, type, titleOrItem, body, timestamp) {
+    async updateIntegrationMessages(id, type, title, body, timestamp) {
         const rec = this.store.get(id);
         if (!rec) {
             this.operationHistory.push({ operation: 'updateMessages', id, success: false });
             return false;
         }
         if (!rec.messages[type]) rec.messages[type] = [];
-        rec.messages[type].push(toMessageItem(titleOrItem, body, timestamp));
+        rec.messages[type].push({ title, message: body, timestamp });
         this.operationHistory.push({ operation: 'updateMessages', id, type, success: true });
         return true;
     }
 
-    async findIntegrationMessages(id, type) {
-        const rec = this.store.get(id);
-        this.operationHistory.push({
-            operation: 'findMessages',
-            id,
-            type,
-            found: !!rec,
-        });
-        if (!rec) throw new Error(`Integration ${id} not found`);
-        return [...(rec.messages[type] ?? [])];
-    }
-
     async updateIntegrationConfig(id, config) {
         if (config === null || config === undefined) {
             throw new Error('Config parameter is required');

package/integrations/use-cases/update-integration-messages.js

@@ -13,21 +13,19 @@ class UpdateIntegrationMessages {
     }
 
     /**
-     * Executes the integration messages update. Pass the positional form
-     * (title, body, timestamp) or one message item object; the keys of an item
-     * object are stored as they are.
+     * Executes the integration messages update.
      * @async
      * @param {string} integrationId - ID of the integration to update.
      * @param {string} messageType - Type of message: 'errors', 'warnings', 'info', or 'logs'.
-     * @param {string|Object} messageTitleOrItem - Title of the message, or the whole message item.
-     * @param {string} [messageBody] - Body content of the message (positional form).
-     * @param {string} [messageTimestamp] - Timestamp when the message was created (positional form).
+     * @param {string} messageTitle - Title of the message.
+     * @param {string} messageBody - Body content of the message.
+     * @param {string} messageTimestamp - Timestamp when the message was created.
      * @returns {Promise<Object>} The updated integration record.
      */
     async execute(
         integrationId,
         messageType,
-        messageTitleOrItem,
+        messageTitle,
         messageBody,
         messageTimestamp
     ) {
@@ -35,7 +33,7 @@ class UpdateIntegrationMessages {
             await this.integrationRepository.updateIntegrationMessages(
                 integrationId,
                 messageType,
-                messageTitleOrItem,
+                messageTitle,
                 messageBody,
                 messageTimestamp
             );

package/logs/serialize.js

@@ -235,6 +235,20 @@ function errorCode(err) {
     return undefined;
 }
 
+function rateLimitFields(err) {
+    const retryAt = attempt(
+        () => (err.isRateLimited ? err.retryAt : undefined),
+        undefined
+    );
+    if (!(retryAt instanceof Date) || Number.isNaN(retryAt.getTime())) {
+        return {};
+    }
+    const reason = attempt(() => err.reason, undefined);
+    return typeof reason === 'string'
+        ? { retryAt: retryAt.toISOString(), reason: cleanString(reason) }
+        : { retryAt: retryAt.toISOString() };
+}
+
 function errorStack(err, type, message) {
     const stack = attempt(() => err.stack, undefined);
     if (typeof stack !== 'string') return undefined;
@@ -279,6 +293,7 @@ function serializeErrorAt(err, depth, seen) {
     if (code !== undefined) out.code = code;
     const status = errorStatus(err);
     if (status !== undefined) out.status = status;
+    Object.assign(out, rateLimitFields(err));
     const stack = errorStack(err, type, message);
     if (stack !== undefined) out.stack = stack;