fix(chat): derive the chat ceiling from the plan table it must stay under

The 60/min ceiling still sat above the free plan's 50/min sync rate, so on free
the shared counter — the one the owner's API, webhook and scheduled runs also
draw from — still emptied before the ceiling refused. Every plan rate is also
operator-overridable through `RATE_LIMIT_*_SYNC`, which no hardcoded number can
track.

It is now derived: 80% of the smallest configured plan sync rate, which is
40/min with the defaults and stays under every plan by construction. The per-IP
bucket follows at half that. Tests assert the invariant against each plan in
`RATE_LIMITS`, on burst as well as sustained rate, rather than pinning numbers
that would need editing the next time a plan default moves.

This floor is shared by all plans, so enterprise is held to the same 40/min as
free. Sizing the slice to the payer's own plan needs the subscription, which
`preprocessExecution` resolves just after this runs — that is the follow-up,
and the same hook bounds the generic-webhook surface that is still unbounded.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWh9WFMYNZ6uTFQFUzF8Bj

Author: waleedlatif1

apps/sim/app/api/chat/[identifier]/route.test.ts

@@ -378,12 +378,12 @@ describe('Chat Identifier API Route', () => {
         expect(mockEnforceIpRateLimit).toHaveBeenCalledWith(
           'chat-execute:chat-id',
           req,
-          expect.objectContaining({ refillRate: 30, refillIntervalMs: 60_000 })
+          expect.objectContaining({ refillIntervalMs: 60_000 })
         )
         expect(mockEnforceResourceRateLimit).toHaveBeenCalledWith(
           'chat-execute',
           'chat-id',
-          expect.objectContaining({ refillRate: 60, refillIntervalMs: 60_000 })
+          expect.objectContaining({ refillIntervalMs: 60_000 })
         )
       })
 
@@ -397,20 +397,37 @@ describe('Chat Identifier API Route', () => {
       })
 
       /**
-       * A chat execution debits the workspace `sync` counter that the owner's
-       * API, webhook and scheduled runs share. A per-deployment ceiling at or
-       * above the plan's own rate would never refuse before that shared counter
-       * was drained, which is the availability half of the attack.
+       * The invariant the ceiling exists to hold. A chat execution debits the
+       * workspace `sync` counter the owner's API, webhook and scheduled runs
+       * share, so a ceiling at or above a plan's own rate never refuses before
+       * that shared counter is drained — the availability half of the attack.
+       * Asserted against every plan, including free, and on burst as well as
+       * sustained rate, since either one reaching the plan bucket first is the
+       * same hole.
        */
-      it('stays below the cheapest paid plan sync rate', async () => {
+      it.each(Object.keys(RATE_LIMITS))(
+        'stays under the %s plan sync budget it debits',
+        async (plan) => {
+          const req = createMockNextRequest('POST', { input: 'hello' })
+
+          await POST(req, { params: Promise.resolve({ identifier: 'test-chat' }) })
+
+          const planBucket = RATE_LIMITS[plan as keyof typeof RATE_LIMITS].sync
+          const [, , config] = mockEnforceResourceRateLimit.mock.calls[0]
+          expect(config.refillRate).toBeLessThan(planBucket.refillRate)
+          expect(config.maxTokens).toBeLessThan(planBucket.maxTokens)
+        }
+      )
+
+      /** One host must not be able to take the whole deployment's allowance. */
+      it('holds the per-IP bucket under the per-deployment one', async () => {
         const req = createMockNextRequest('POST', { input: 'hello' })
 
         await POST(req, { params: Promise.resolve({ identifier: 'test-chat' }) })
 
-        const [, , config] = mockEnforceResourceRateLimit.mock.calls[0]
-        expect(config.refillRate).toBeLessThan(RATE_LIMITS.pro.sync.refillRate)
-        expect(config.refillRate).toBeLessThan(RATE_LIMITS.team.sync.refillRate)
-        expect(config.refillRate).toBeLessThan(RATE_LIMITS.enterprise.sync.refillRate)
+        const [, , ipConfig] = mockEnforceIpRateLimit.mock.calls[0]
+        const [, , deploymentConfig] = mockEnforceResourceRateLimit.mock.calls[0]
+        expect(ipConfig.refillRate).toBeLessThan(deploymentConfig.refillRate)
       })
 
       it('leaves the gate-configuration fetch unmetered', async () => {

apps/sim/app/api/chat/[identifier]/route.ts

@@ -14,6 +14,7 @@ import {
   enforceResourceRateLimit,
   type TokenBucketConfig,
 } from '@/lib/core/rate-limiter'
+import { RATE_LIMITS } from '@/lib/core/rate-limiter/types'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
@@ -60,31 +61,44 @@ function executionsPerMinute(perMinute: number): TokenBucketConfig {
 }
 
 /**
- * Executions one client IP may drive against a single deployed chat.
+ * What one deployed chat may spend of its owner's workspace allowance.
+ *
+ * A chat execution debits the workspace `sync` counter, which is the same
+ * counter the owner's API, webhook and scheduled runs draw from. So this
+ * ceiling only does its job while it sits *below* that counter: above it, a
+ * flood empties the shared budget before this bucket ever refuses, and the
+ * billing attack becomes an availability attack on unrelated production
+ * workloads.
+ *
+ * Derived from the plan table rather than picked, because no fixed number holds
+ * that invariant — the rates differ per plan and every one is operator
+ * overridable through `RATE_LIMIT_*_SYNC`. A fraction of the smallest
+ * configured rate keeps a public chat under the shared budget on every plan and
+ * cannot drift if one of those defaults changes.
  *
- * A deployed chat runs the owner's workflow on the owner's plan bucket, credit
- * balance and concurrency reservation for whoever holds the link, so every
- * ceiling on that path belongs to the payer and none of them bound the caller.
- * Half the per-deployment rate, so one host cannot monopolize the deployment's
- * whole allowance, and still far above human chat cadence — a burst of 60 then
- * one message every two seconds — so shared NAT does not cost a real audience
- * its session.
+ * The floor is deliberately shared by all plans for now. Sizing the slice to
+ * the *payer's* own plan needs the subscription, which `preprocessExecution`
+ * resolves a few lines after this runs, not here.
  */
-const CHAT_EXECUTION_IP_LIMIT = executionsPerMinute(30)
+const CHAT_EXECUTION_RATE_PER_MINUTE = Math.max(
+  1,
+  Math.floor(Math.min(...Object.values(RATE_LIMITS).map((plan) => plan.sync.refillRate)) * 0.8)
+)
+
+const CHAT_EXECUTION_LIMIT = executionsPerMinute(CHAT_EXECUTION_RATE_PER_MINUTE)
 
 /**
- * What one deployed chat may spend of its owner's workspace allowance.
+ * Executions one client IP may drive against a single deployed chat.
  *
- * This has to sit *below* the owner's plan bucket to do its job. A chat
- * execution debits the workspace `sync` counter — 50/min on free, 150 on pro,
- * 300 on team, 600 on enterprise — which is the same counter the owner's API,
- * webhook and scheduled runs draw from. A ceiling above it would let a flood
- * empty that shared counter before this bucket ever refused, which is how a
- * billing attack becomes an availability attack on unrelated production
- * workloads. At 60/min a public chat can spend at most a fraction of even the
- * cheapest paid plan and the owner's other triggers keep their headroom.
+ * Half the per-deployment rate, so a single source can never consume the whole
+ * allowance and leave the rest of the audience with none. It is above one
+ * person's chat cadence but not above a busy office behind one NAT — which
+ * costs little in practice, since traffic that heavy from one address would
+ * meet the per-deployment ceiling moments later anyway.
  */
-const CHAT_EXECUTION_LIMIT = executionsPerMinute(60)
+const CHAT_EXECUTION_IP_LIMIT = executionsPerMinute(
+  Math.max(1, Math.floor(CHAT_EXECUTION_RATE_PER_MINUTE / 2))
+)
 
 export const POST = withRouteHandler(
   async (request: NextRequest, context: { params: Promise<{ identifier: string }> }) => {