fix(chat): drop the env knobs and put the ceiling under the plan bucket

Two corrections to the execution throttle.

The per-deployment ceiling was 300/min, at or above the workspace `sync`
counter it debits on every plan but enterprise — 50 free, 150 pro, 300 team.
A flood therefore drained that shared counter, which the owner's API, webhook
and scheduled runs draw from too, before the ceiling ever refused: the
availability half of the report went unmitigated on exactly the plans most
workspaces are on. It is now 60/min sustained, under even the cheapest paid
plan, with a test that pins it there against `RATE_LIMITS`. The per-IP bucket
drops to 30/min so one host cannot take a deployment's whole allowance, and
both gain the 2x burst allowance the plan buckets already use.

Both limits go back to plain constants. Every sibling deployment throttle —
password, OTP, SSO, on chat and on public file shares — is a hardcoded
`TokenBucketConfig`, so the two env vars were the only configurable ones of
their kind and bought speculative tuning for a control with sane defaults.

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

Author: waleedlatif1

apps/docs/content/docs/platform/self-hosting/environment-variables.mdx

@@ -159,8 +159,6 @@ Without a remote provider, user code runs in an in-process V8 isolate inside the
 | `API_MAX_JSON_BODY_BYTES` | 50 MB | Max JSON body on contract-validated API routes |
 | `CHAT_MAX_REQUEST_BYTES` | 220 MB | Max body on the public deployed-chat endpoint |
 | `WEBHOOK_MAX_REQUEST_BYTES` | 10 MB | Max body on public webhook receiver endpoints |
-| `DEPLOYMENT_IP_EXECUTIONS_PER_MINUTE` | `60` | Executions one client IP may drive against a single deployed chat |
-| `DEPLOYMENT_EXECUTIONS_PER_MINUTE` | `300` | Executions one deployed chat may serve per minute across all callers |
 | `WORKFLOW_EXECUTION_CONCURRENCY_LIMIT` | `75` | Workflow executions in parallel |
 | `WEBHOOK_EXECUTION_CONCURRENCY_LIMIT` | `75` | Webhook-triggered executions in parallel |
 | `SCHEDULE_EXECUTION_CONCURRENCY_LIMIT` | `30` | Scheduled executions in parallel |

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

@@ -131,6 +131,7 @@ vi.mock('@/lib/core/rate-limiter', () => ({
   enforceResourceRateLimit: mockEnforceResourceRateLimit,
 }))
 
+import { RATE_LIMITS } from '@/lib/core/rate-limiter/types'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
 import { executeWorkflow } from '@/lib/workflows/executor/execute-workflow'
 import { createStreamingResponse } from '@/lib/workflows/streaming/streaming'
@@ -377,12 +378,12 @@ describe('Chat Identifier API Route', () => {
         expect(mockEnforceIpRateLimit).toHaveBeenCalledWith(
           'chat-execute:chat-id',
           req,
-          expect.objectContaining({ refillIntervalMs: 60_000 })
+          expect.objectContaining({ refillRate: 30, refillIntervalMs: 60_000 })
         )
         expect(mockEnforceResourceRateLimit).toHaveBeenCalledWith(
           'chat-execute',
           'chat-id',
-          expect.objectContaining({ refillIntervalMs: 60_000 })
+          expect.objectContaining({ refillRate: 60, refillIntervalMs: 60_000 })
         )
       })
 
@@ -395,6 +396,23 @@ describe('Chat Identifier API Route', () => {
         expect(mockEnforceResourceRateLimit).not.toHaveBeenCalled()
       })
 
+      /**
+       * 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.
+       */
+      it('stays below the cheapest paid plan sync rate', 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)
+      })
+
       it('leaves the gate-configuration fetch unmetered', async () => {
         const passwordDeployment = {
           ...mockChatResult[0],

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

@@ -8,7 +8,7 @@ import { deployedChatPostContract } from '@/lib/api/contracts/chats'
 import { parseRequest } from '@/lib/api/server'
 import { releaseExecutionSlot } from '@/lib/billing/calculations/usage-reservation'
 import { admissionRejectedResponse, tryAdmit } from '@/lib/core/admission/gate'
-import { env, envNumber } from '@/lib/core/config/env'
+import { env } from '@/lib/core/config/env'
 import {
   enforceIpRateLimitWithIndependentBackstop,
   enforceResourceRateLimit,
@@ -54,10 +54,9 @@ export const runtime = 'nodejs'
 
 const CHAT_MAX_REQUEST_BYTES = Number.parseInt(env.CHAT_MAX_REQUEST_BYTES, 10) || 220 * 1024 * 1024
 
-/** A per-minute ceiling, as a bucket that refills its whole allowance each minute. */
-function executionsPerMinute(value: string | undefined, fallback: number): TokenBucketConfig {
-  const perMinute = envNumber(value, fallback, { min: 1, integer: true })
-  return { maxTokens: perMinute, refillRate: perMinute, refillIntervalMs: 60_000 }
+/** A sustained per-minute rate, with the 2x burst allowance the plan buckets use. */
+function executionsPerMinute(perMinute: number): TokenBucketConfig {
+  return { maxTokens: perMinute * 2, refillRate: perMinute, refillIntervalMs: 60_000 }
 }
 
 /**
@@ -66,16 +65,26 @@ function executionsPerMinute(value: string | undefined, fallback: number): Token
  * 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.
- * Sized well above a human conversation and above shared-NAT aggregation, so it
- * costs a flooder a botnet rather than costing a real audience its session.
+ * 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.
  */
-const CHAT_EXECUTION_IP_LIMIT = executionsPerMinute(env.DEPLOYMENT_IP_EXECUTIONS_PER_MINUTE, 60)
+const CHAT_EXECUTION_IP_LIMIT = executionsPerMinute(30)
 
 /**
- * What bounds the owner's exposure when attempts are spread across addresses,
- * and the only bound left when the proxy chain resolves to no client IP.
+ * What one deployed chat may spend of its owner's workspace allowance.
+ *
+ * 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.
  */
-const CHAT_EXECUTION_LIMIT = executionsPerMinute(env.DEPLOYMENT_EXECUTIONS_PER_MINUTE, 300)
+const CHAT_EXECUTION_LIMIT = executionsPerMinute(60)
 
 export const POST = withRouteHandler(
   async (request: NextRequest, context: { params: Promise<{ identifier: string }> }) => {

apps/sim/lib/core/config/env.ts

@@ -403,8 +403,6 @@ export const env = createEnv({
 
     // Rate Limiting Configuration
     RATE_LIMIT_WINDOW_MS:                  z.string().optional().default('60000'), // Rate limit window duration in milliseconds (default: 1 minute)
-    DEPLOYMENT_IP_EXECUTIONS_PER_MINUTE:   z.string().optional().default('60'),   // Executions one client IP may drive against a single deployed chat, billed to that chat's owner
-    DEPLOYMENT_EXECUTIONS_PER_MINUTE:      z.string().optional().default('300'),  // Executions one deployed chat may serve per minute across all callers (owner-spend backstop)
     MANUAL_EXECUTION_LIMIT:                z.string().optional().default('999999'),// Manual execution bypass value (effectively unlimited)
     RATE_LIMIT_FREE_SYNC:                  z.string().optional(),                  // Free tier sync API executions per minute (default 50). With billing disabled, setting it explicitly opts into rate limiting
     RATE_LIMIT_FREE_ASYNC:                 z.string().optional(),                  // Free tier async API executions per minute (default 200). With billing disabled, setting it explicitly opts into rate limiting