@friggframework/core 2.0.0--canary.658.164d92b.0 → 2.0.0--canary.657.6a81b60.0

package/CLAUDE.md

@@ -483,21 +483,22 @@ handlers (`{ req, res, next }`) and `this.on` events do not.
 
 `isLastAttempt` is `false` when either count is unknown: a local or non-SQS
 invocation, or a queue whose redrive policy the stack does not own
-(`ownership.queue: 'external'`). The value is information only: core still
-rethrows retryable errors and discards halt errors (4xx except 408, 429 and
-errors with `isRateLimited`).
+(`ownership.queue: 'external'`). The value does not change what core does: a
+retryable error returns the message to SQS, a rate-limited error puts it back
+to run at `retryAt` (see **Rate-limit deferral** below), and a halt error (4xx
+except 408, 429 and errors with `isRateLimited`) discards it.
 
-Use it to end a run or count lost work on the final try: when a retryable
-error (429, 5xx, network) is about to be rethrown and `isLastAttempt` is
-`true`, the message goes to the DLQ next, so mark the run failed or count the
-message's records as failed before rethrowing.
+Use it to end a run or count lost work on the final try. Check it first: when
+it is `true`, mark the run failed or count the message's records as failed, and
+return. Otherwise rethrow. Do not end the run and then rethrow: core can still
+send a `RateLimitError` again, so the message would run again on an ended run.
 
 ```javascript
 async processBatch({ data, delivery }) {
     try {
         await this.syncPage(data);
     } catch (error) {
-        if (delivery?.isLastAttempt) await this.failRun(data.processId, error);
+        if (delivery?.isLastAttempt) return this.failRun(data.processId, error);
         throw error;
     }
 }
@@ -508,6 +509,71 @@ The single source of the max receive count is
 devtools integration builder uses it for the queue's `RedrivePolicy` and sets
 it as `FRIGG_QUEUE_MAX_RECEIVE_COUNT` on the queue worker function.
 
+**Rate-limit deferral** (ADR-049): when a queue handler throws an error with
+`isRateLimited` and a `retryAt` (a `RateLimitError` from the Requester, or one a
+module throws), `Worker.run` does not give the message back to SQS for a 30
+minute redelivery. It puts the message back so it runs at `retryAt`:
+
+| Wait | What the worker does | Record |
+|---|---|---|
+| Up to 900 s | Sends the same body again with `DelaySeconds`, then acknowledges the old message | handled |
+| Over 900 s, and `SCHEDULER_ROLE_ARN` is set | Creates a one-time EventBridge schedule at `retryAt` that sends the body to the queue, then acknowledges | handled |
+| Over 900 s, no scheduler | Extends the message's visibility timeout to `retryAt` (12 h less 20 minutes at most). This uses one receive | reported failed |
+
+- The new message starts at receive count 1. A deferred body carries
+  `_frigg: { deferrals, firstDeferredAt }`; `_frigg` is reserved and the handler
+  never sees it.
+- The visibility tier sets a timeout of at most 12 h less 20 minutes
+  (42,000 s). SQS counts its 12 h maximum from the receive, and an extension
+  does not reset it. The margin covers the longest Lambda run (900 s) plus the
+  longest batching window (300 s).
+- Two caps bound it: `FRIGG_QUEUE_MAX_DEFERRALS` (default 30) and
+  `FRIGG_QUEUE_MAX_DEFERRED_MS` (default 26 h, from the first deferral to the
+  retry time). The defaults cover one full day of hourly waits, for a module
+  that probes a daily limit every hour. Past a cap, with no `retryAt`, with no
+  event source ARN or on a FIFO queue, the record fails like any retryable
+  error and `delivery` applies.
+- The mock scheduler is never used for a deferral: a schedule kept in memory
+  would be lost with the acknowledged message.
+- With a `processId` in the message, the worker writes
+  `Process.context.rateLimit = { status: 'WAITING' | 'EXHAUSTED', mechanism,
+  retryAt, reason, module, deferrals, updatedAt }`. `EXHAUSTED` means a cap ended
+  the deferrals, or a visibility change came on the last delivery. The value is
+  one per process, so it holds the latest known wait: a new wait replaces it only
+  when its `retryAt` is later, a `WAITING` value never hides an `EXHAUSTED` one,
+  and after a deferred or redelivered message ran the worker sets it to `null`
+  only when it is `WAITING` and its `retryAt` is past or within 5 s.
+- Delivery stays at least once. The new message is sent before the old one is
+  acknowledged, so a crash between the two can run the work twice.
+- Handlers check `delivery.isLastAttempt` first, then rethrow. The delay and
+  schedule tiers send a new message, so they never reach the last attempt. The
+  visibility tier and a cap use a receive: on the last one the worker writes an
+  ERROR (`frigg.worker.record_lost_rate_limited`), and the handler has this one
+  chance to end the run.
+
+```javascript
+async processBatch({ data, delivery }) {
+    try {
+        await this.syncPage(data);
+    } catch (error) {
+        if (delivery?.isLastAttempt) return this.failRun(data.processId, error);
+        throw error; // a RateLimitError too: core puts the message back at retryAt
+    }
+}
+```
+
+Records: a rate-limited SQS record gets one log record, by its outcome.
+
+| Outcome | Log record |
+|---|---|
+| Acknowledged | WARN `frigg.worker.record_deferred` (`mechanism` `delay` or `schedule`) |
+| Not acknowledged, not the last attempt | One WARN: `record_deferral_capped`, `record_visibility_extended`, or `record_failed` with `deferral.skipped` |
+| Not acknowledged, last attempt | One ERROR, `record_lost_rate_limited`, with the details, and no WARN |
+
+A failing run state hook adds `rate_limit_state_failed`. A queue in a stack
+that does not own it (`ownership.queue: 'external'`) needs its own
+`sqs:ChangeMessageVisibility` and scheduler access.
+
 ### 8. Error Handling (`/errors`)
 
 **Purpose**: Standardized error types with proper HTTP semantics.
@@ -530,50 +596,6 @@ if (!userId) {
 }
 ```
 
-**Rate-limit message** (ADR-049): when a wait is longer than the in-process cap
-(`maxInProcessWaitMs`, default 5 min), the Requester tells its delegate
-(`RATE_LIMITED`, with the `RateLimitError`) and then throws. A shorter wait
-that throws sends no notification. 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.
-
-Integration messages (the item form, `findIntegrationMessages`, the newest 50
-per type): see "Integration Messages" in `docs/guides/INTEGRATION-PATTERNS.md`.
-
 ### 9. Logging System (`/logs`)
 
 **Purpose**: One redacted JSON record per line to stdout (ADR-048). See `docs/guides/LOGGING.md`.
@@ -803,6 +825,8 @@ Use test doubles from `@friggframework/test` package for consistent mocking.
 - `SECRET_ARN` - AWS Secrets Manager ARN for auto-injection
 - `FRIGG_LOG_LEVEL` - Minimum log level (`TRACE` … `FATAL`, default `INFO`; `DEBUG` on local runs)
 - `FRIGG_QUEUE_MAX_RECEIVE_COUNT` - Set by devtools on integration queue workers whose queue the stack owns; feeds `delivery.maxReceiveCount`
+- `FRIGG_QUEUE_MAX_DEFERRALS` - Most rate-limit deferrals of one message (default 30)
+- `FRIGG_QUEUE_MAX_DEFERRED_MS` - Most time in ms from a message's first rate-limit deferral to its retry time (default 26 h)
 
 ## Version Information
 

package/core/CLAUDE.md

@@ -79,6 +79,31 @@ await worker.send({
 }, delaySeconds);
 ```
 
+**Rate-limit deferral** (ADR-049): `run()` handles an error with `isRateLimited`
+and a `retryAt` through `defer(record, body, error, delivery)`, which returns
+`{ outcome }`:
+- `acked`: the message was sent again with `DelaySeconds` (wait up to 900 s) or
+  scheduled with the one-time scheduler (longer wait). The record is handled.
+- `failed`: the visibility timeout was extended to `retryAt`, or a cap
+  (`FRIGG_QUEUE_MAX_DEFERRALS`, `FRIGG_QUEUE_MAX_DEFERRED_MS`) ended the
+  deferrals. The record is reported failed.
+- `skipped`: no `retryAt` (`no_retry_at`), no `eventSourceARN` or a FIFO queue
+  (`no_event_source`), a failed send (`send_failed`), or a failed visibility
+  change (`visibility_failed`). The record fails as any error does.
+
+Each outcome writes one log record. `acked` writes WARN `record_deferred`.
+`failed` and `skipped` write one WARN (`record_visibility_extended`,
+`record_deferral_capped`, or `record_failed` with `deferral: { skipped }`). On
+the last attempt they write one ERROR, `record_lost_rate_limited`, with the
+details, and no WARN.
+
+Subclasses override two no-op hooks to keep run state: `recordRateLimitWait(body,
+error, state)` runs after the message was put back, and `clearRateLimitWait(body)`
+runs after a deferred or redelivered message succeeded. A failing hook logs
+`frigg.worker.rate_limit_state_failed` and never changes the outcome. The queue
+worker of an integration (`createQueueWorker`) writes `Process.context.rateLimit`
+in them. See `packages/core/CLAUDE.md` section 7.
+
 ### Delegate Pattern System (`Delegate.js:3-27`)
 
 **Purpose**: Observer/delegation pattern for decoupled component communication

package/core/Worker.js

@@ -1,14 +1,38 @@
-const { SQSClient, GetQueueUrlCommand, SendMessageCommand } = require('@aws-sdk/client-sqs');
+const {
+    SQSClient,
+    GetQueueUrlCommand,
+    SendMessageCommand,
+    ChangeMessageVisibilityCommand,
+} = require('@aws-sdk/client-sqs');
 const _ = require('lodash');
 const { RequiredPropertyError } = require('../errors');
 const { get } = require('../assertions');
 const { readQueueDelivery } = require('../queues/queue-delivery');
+const { awsConfigOptions } = require('../queues/queuer-util');
+const {
+    MAX_DEFERRED_VISIBILITY_SECONDS,
+    MAX_DELAY_SECONDS,
+    deferredMs,
+    isDeferralCapped,
+    nextDeferral,
+    readDeferral,
+    readDeferralLimits,
+    withDeferral,
+} = require('../queues/queue-deferral');
 const { runMessageScope } = require('./invocation-scope');
 const { getLogger } = require('../logs');
 
-const sqs = new SQSClient({ region: process.env.AWS_REGION });
+const sqs = new SQSClient({
+    region: process.env.AWS_REGION,
+    ...awsConfigOptions(),
+});
 const log = getLogger('frigg.worker');
 
+const validDate = (value) =>
+    value instanceof Date && !Number.isNaN(value.getTime()) ? value : null;
+const queueNameOf = (arn) =>
+    typeof arn === 'string' && arn ? arn.split(':').pop() : undefined;
+
 class Worker {
     async getQueueURL(params) {
         // Passing params in because there will be multiple QueueNames
@@ -33,12 +57,31 @@ class Worker {
                 // messageId, receiveCount and the event come from the scope.
                 log.debug('Record started', { eventName: 'frigg.worker.record_started' });
 
+                const delivery = readQueueDelivery(record);
+                let runParams;
                 try {
-                    const runParams = JSON.parse(record.body);
+                    runParams = JSON.parse(record.body);
                     this._validateParams(runParams);
-                    await this._run(runParams, context, readQueueDelivery(record));
+                    await this._run(runParams, context, delivery);
+                    await this._clearDeferredState(runParams, delivery);
                     log.debug('Record succeeded', { eventName: 'frigg.worker.record_succeeded' });
                 } catch (error) {
+                    let deferralResult;
+                    if (error.isRateLimited && runParams) {
+                        deferralResult = await this.defer(
+                            record,
+                            runParams,
+                            error,
+                            delivery
+                        );
+                        if (deferralResult.outcome === 'acked') return;
+                        if (deferralResult.outcome === 'failed') {
+                            batchItemFailures.push({
+                                itemIdentifier: record.messageId,
+                            });
+                            return;
+                        }
+                    }
                     if (error.isHaltError) {
                         // HaltError means "discard this message, don't retry".
                         // Treat as success so SQS deletes it from the queue.
@@ -51,11 +94,30 @@ class Worker {
                         });
                         return;
                     }
-                    // The message goes back to SQS, so WARN (ADR-048 §4).
-                    log.warn('Record failed, returned for retry', {
-                        eventName: 'frigg.worker.record_failed',
-                        error,
-                    });
+                    const skippedDeferral = deferralResult && {
+                        deferral: {
+                            skipped: deferralResult.skipped,
+                            ...(deferralResult.cause && {
+                                cause: deferralResult.cause,
+                            }),
+                        },
+                    };
+                    if (skippedDeferral && delivery.isLastAttempt) {
+                        this._logLost({
+                            retryAt: validDate(error.retryAt)?.toISOString(),
+                            reason: error.reason,
+                            module: error.module,
+                            ...skippedDeferral,
+                            error,
+                        });
+                    } else {
+                        // The message goes back to SQS, so WARN (ADR-048 §4).
+                        log.warn('Record failed, returned for retry', {
+                            eventName: 'frigg.worker.record_failed',
+                            error,
+                            ...skippedDeferral,
+                        });
+                    }
                     batchItemFailures.push({ itemIdentifier: record.messageId });
                 }
             });
@@ -75,6 +137,239 @@ class Worker {
         // parameters
     }
 
+    async defer(record, body, error, delivery) {
+        const retryAt = validDate(error.retryAt);
+        if (!retryAt) return { outcome: 'skipped', skipped: 'no_retry_at' };
+        const queueName = queueNameOf(record.eventSourceARN);
+        if (!queueName || queueName.endsWith('.fifo')) {
+            return { outcome: 'skipped', skipped: 'no_event_source' };
+        }
+
+        const now = Date.now();
+        const counters = nextDeferral(body, now);
+        const deferral = {
+            record,
+            queueName,
+            body,
+            deferredBody: withDeferral(body, counters),
+            error,
+            delivery,
+            retryAt,
+            waitMs: Math.max(0, retryAt.getTime() - now),
+            counters,
+        };
+
+        const limits = readDeferralLimits();
+        if (isDeferralCapped({ ...counters, retryAt }, limits)) {
+            await this._recordWait(deferral, 'EXHAUSTED', 'none');
+            this._logUnacked(
+                deferral,
+                'record_deferral_capped',
+                'Rate-limit deferral capped',
+                {
+                    maxDeferrals: limits.maxDeferrals,
+                    maxDeferredMs: limits.maxDeferredMs,
+                    deferredMs: deferredMs({ ...counters, retryAt }),
+                }
+            );
+            return { outcome: 'failed' };
+        }
+
+        if (deferral.waitMs <= MAX_DELAY_SECONDS * 1000)
+            return this._deferWithDelay(deferral);
+        const scheduled = await this._deferWithSchedule(deferral);
+        if (scheduled?.outcome) return scheduled;
+        return this._deferWithVisibility(deferral, scheduled?.scheduleError);
+    }
+
+    async _deferWithDelay(deferral) {
+        const delaySeconds = Math.ceil(deferral.waitMs / 1000);
+        try {
+            const queueUrl = await this._queueUrl(deferral.queueName);
+            await this.send(
+                { ...deferral.deferredBody, QueueUrl: queueUrl },
+                delaySeconds
+            );
+        } catch (cause) {
+            return { outcome: 'skipped', skipped: 'send_failed', cause };
+        }
+        return this._acknowledgeDeferral(deferral, 'delay', { delaySeconds });
+    }
+
+    async _deferWithSchedule(deferral) {
+        const { record, retryAt, deferredBody } = deferral;
+        const scheduleName = `frigg-defer-${record.messageId}`;
+        try {
+            const scheduler = this.getSchedulerService();
+            if (!scheduler) return null;
+            await scheduler.scheduleOneTime({
+                scheduleName,
+                scheduleAt: retryAt,
+                queueResourceId: record.eventSourceARN,
+                payload: deferredBody,
+            });
+        } catch (cause) {
+            if (cause?.name !== 'ConflictException')
+                return { scheduleError: cause };
+        }
+        return this._acknowledgeDeferral(deferral, 'schedule', {
+            scheduleName,
+        });
+    }
+
+    async _deferWithVisibility(deferral, scheduleError) {
+        const { record, queueName, delivery, waitMs } = deferral;
+        const visibilityTimeout = Math.min(
+            Math.ceil(waitMs / 1000),
+            MAX_DEFERRED_VISIBILITY_SECONDS
+        );
+        try {
+            const queueUrl = await this._queueUrl(queueName);
+            await sqs.send(
+                new ChangeMessageVisibilityCommand({
+                    QueueUrl: queueUrl,
+                    ReceiptHandle: record.receiptHandle,
+                    VisibilityTimeout: visibilityTimeout,
+                })
+            );
+        } catch (cause) {
+            return { outcome: 'skipped', skipped: 'visibility_failed', cause };
+        }
+        await this._recordWait(
+            deferral,
+            delivery.isLastAttempt ? 'EXHAUSTED' : 'WAITING',
+            'visibility'
+        );
+        this._logUnacked(
+            deferral,
+            'record_visibility_extended',
+            'Record visibility extended',
+            {
+                mechanism: 'visibility',
+                visibilityTimeout,
+                ...(scheduleError && { scheduleError }),
+            }
+        );
+        return { outcome: 'failed' };
+    }
+
+    async _acknowledgeDeferral(deferral, mechanism, fields) {
+        await this._recordWait(deferral, 'WAITING', mechanism);
+        log.warn('Record deferred', {
+            eventName: 'frigg.worker.record_deferred',
+            mechanism,
+            ...fields,
+            ...this._deferralLogFields(deferral),
+            error: deferral.error,
+        });
+        return { outcome: 'acked' };
+    }
+
+    getSchedulerService() {
+        if (this._schedulerService !== undefined) return this._schedulerService;
+        if (
+            !process.env.SCHEDULER_ROLE_ARN ||
+            process.env.SCHEDULER_PROVIDER === 'mock'
+        ) {
+            this._schedulerService = null;
+            return null;
+        }
+        const {
+            createSchedulerService,
+            SCHEDULER_PROVIDERS,
+        } = require('../infrastructure/scheduler/scheduler-service-factory');
+        this._schedulerService = createSchedulerService({
+            provider: SCHEDULER_PROVIDERS.EVENTBRIDGE,
+        });
+        return this._schedulerService;
+    }
+
+    recordRateLimitWait() {
+        return Promise.resolve();
+    }
+
+    clearRateLimitWait() {
+        return Promise.resolve();
+    }
+
+    _queueUrl(queueName) {
+        this._queueUrls ??= new Map();
+        if (!this._queueUrls.has(queueName)) {
+            const lookup = this.getQueueURL({ QueueName: queueName }).catch(
+                (error) => {
+                    this._queueUrls.delete(queueName);
+                    throw error;
+                }
+            );
+            this._queueUrls.set(queueName, lookup);
+        }
+        return this._queueUrls.get(queueName);
+    }
+
+    async _recordWait({ body, error, counters, retryAt }, status, mechanism) {
+        await this._runStateHook('record', () =>
+            this.recordRateLimitWait(body, error, {
+                status,
+                mechanism,
+                deferrals: counters.deferrals,
+                retryAt,
+            })
+        );
+    }
+
+    async _clearDeferredState(body, delivery) {
+        const redelivered = delivery.receiveCount > 1;
+        if (readDeferral(body).deferrals === 0 && !redelivered) return;
+        await this._runStateHook('clear', () => this.clearRateLimitWait(body));
+    }
+
+    async _runStateHook(operation, hook) {
+        try {
+            await hook();
+        } catch (error) {
+            log.warn('Rate-limit run state not written', {
+                eventName: 'frigg.worker.rate_limit_state_failed',
+                operation,
+                error,
+            });
+        }
+    }
+
+    _deferralLogFields({ error, retryAt, waitMs, counters }) {
+        return {
+            waitMs,
+            retryAt: retryAt.toISOString(),
+            deferrals: counters.deferrals,
+            firstDeferredAt: counters.firstDeferredAt,
+            reason: error.reason,
+            module: error.module,
+            statusCode: error.statusCode,
+        };
+    }
+
+    _logUnacked(deferral, eventName, message, fields) {
+        const logFields = {
+            ...fields,
+            ...this._deferralLogFields(deferral),
+            error: deferral.error,
+        };
+        if (deferral.delivery.isLastAttempt) {
+            this._logLost(logFields);
+            return;
+        }
+        log.warn(message, {
+            eventName: `frigg.worker.${eventName}`,
+            ...logFields,
+        });
+    }
+
+    _logLost(fields) {
+        log.error(
+            'Rate-limited record lost: the message goes to the dead-letter queue next',
+            { eventName: 'frigg.worker.record_lost_rate_limited', ...fields }
+        );
+    }
+
     // returns the message id
     async send(params, delay = 0) {
         this._validateParams(params);

package/handlers/backend-utils.js

@@ -21,6 +21,12 @@ const {
     getModulesDefinitionFromIntegrationClasses,
 } = require('../integrations/utils/map-integration-dto');
 const { processNotFound } = require('../integrations/use-cases/process-errors');
+const {
+    RecordRateLimitWait,
+} = require('../integrations/use-cases/record-rate-limit-wait');
+const {
+    ClearRateLimitWait,
+} = require('../integrations/use-cases/clear-rate-limit-wait');
 
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
     const router = Router();
@@ -165,6 +171,28 @@ const createQueueWorker = (integrationClass) => {
     const integrationName = integrationClass.Definition.name;
 
     class QueueWorker extends Worker {
+        async recordRateLimitWait(body, error, state) {
+            const processId = body.data?.processId;
+            if (!processId) return;
+            const recordRateLimitWait = new RecordRateLimitWait({
+                processRepository: createProcessRepository(),
+            });
+            await recordRateLimitWait.execute(processId, {
+                ...state,
+                reason: error.reason,
+                module: error.module,
+            });
+        }
+
+        async clearRateLimitWait(body) {
+            const processId = body?.data?.processId;
+            if (!processId) return;
+            const clearRateLimitWait = new ClearRateLimitWait({
+                processRepository: createProcessRepository(),
+            });
+            await clearRateLimitWait.execute(processId);
+        }
+
         async _run(params, context, delivery) {
             const logCtx = {
                 integration: integrationName,

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(), () =>
@@ -914,16 +908,6 @@ class IntegrationBase {
             });
             await this.persistStatus('ENABLED');
         }
-
-        if (delegateString === 'RATE_LIMITED') {
-            this.logger.warn('Module reported a rate limit', {
-                eventName: `${this.logger.name}.rate_limited`,
-                moduleName: object?.moduleName,
-                reason: object?.reason,
-                retryAt: object?.retryAt,
-            });
-            await this.recordRateLimitMessage.execute(this.id, object);
-        }
     }
 
     /**

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

@@ -14,7 +14,6 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
-const { messagesOfType } = require('./message-item-shared');
 
 class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     constructor() {
@@ -95,8 +94,9 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     async updateIntegrationMessages(
         integrationId,
         messageType,
-        item,
-        { keepLast }
+        messageTitle,
+        messageBody,
+        messageTimestamp
     ) {
         const objectId = toObjectId(integrationId);
         if (!objectId) {
@@ -107,12 +107,13 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
             throw new Error(`Integration ${integrationId} not found`);
         }
         const messages = this._extractMessages(existing);
-        const list = [...messagesOfType(messages, messageType)];
-        list.push({ ...item, title: item.title ?? null });
-        const updatedMessages = {
-            ...messages,
-            [messageType]: list.slice(-keepLast),
-        };
+        const list = Array.isArray(messages[messageType]) ? [...messages[messageType]] : [];
+        list.push({
+            title: messageTitle ?? null,
+            message: messageBody,
+            timestamp: messageTimestamp,
+        });
+        const updatedMessages = { ...messages, [messageType]: list };
         await updateOne(
             this.prisma,
             'Integration',
@@ -131,20 +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`);
-        }
-        return messagesOfType(this._extractMessages(existing), messageType);
-    }
-
     async createIntegration(entities, userId, config) {
         const now = new Date();
         const document = {