fix(billing): read free payers fresh in the provider check and judge free by the admitted plan

Author: waleedlatif1

apps/sim/app/api/billing/update-cost/route.integration.ts

@@ -195,7 +195,7 @@ function attributedCallback(
   })
 }
 
-async function usageExceeded(response: Promise<Response>): Promise<boolean> {
+async function usageExceeded(response: ReturnType<typeof POST>): Promise<boolean> {
   const res = await response
   expect(res.status).toBe(200)
   return (await res.json()).usageExceeded

apps/sim/app/api/billing/update-cost/route.test.ts

@@ -1027,10 +1027,10 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
 
   it('reads a free payer standing past its cached admission after every charge', async () => {
     mockCheckAttributedUsageLimits.mockResolvedValue({ isExceeded: false })
-    expect((await (await POST(attributedCallback())).json()).usageExceeded).toBe(false)
+    expect((await (await POST(attributedCallback(), {})).json()).usageExceeded).toBe(false)
 
     mockCheckAttributedUsageLimits.mockResolvedValue({ isExceeded: true, scope: 'payer' })
-    await expect((await POST(attributedCallback())).json()).resolves.toMatchObject({
+    await expect((await POST(attributedCallback(), {})).json()).resolves.toMatchObject({
       usageExceeded: true,
       usageUpgrade: { action: 'upgrade_plan' },
     })
@@ -1249,7 +1249,7 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
   ])('pauses a free run for %s, keeping the recorded charge', async (_case, answer) => {
     answer()
 
-    const res = await POST(attributedCallback())
+    const res = await POST(attributedCallback(), {})
 
     expect(res.status).toBe(200)
     await expect(res.json()).resolves.toMatchObject({
@@ -1266,7 +1266,7 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
       scope: 'payer',
     })
 
-    expect((await (await POST(attributedCallback())).json()).usageExceeded).toBe(false)
+    expect((await (await POST(attributedCallback(), {})).json()).usageExceeded).toBe(false)
   })
 
   it('tells a member over the cap their organization set who can raise it', async () => {
@@ -1370,7 +1370,7 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
           return { isExceeded: false }
         })
 
-        const pending = POST(attributedCallback())
+        const pending = POST(attributedCallback(), {})
         await vi.advanceTimersByTimeAsync(1000)
         const res = await pending
 

apps/sim/app/api/copilot/api-keys/validate/route.test.ts

@@ -661,12 +661,12 @@ describe('validation lifecycle purposes', () => {
         payerSubscriptionId: 'sub-account-org',
       }),
     }
-    expect((await POST(request(body, paidHeaders))).status).toBe(200)
+    expect((await POST(request(body, paidHeaders), {})).status).toBe(200)
   })
 
   it('refuses a free direct-v1 continuation whose usage cannot be read', async () => {
     mockCheckUsageStatus.mockResolvedValue({ isExceeded: true, unavailable: true })
-    expect((await POST(request(body, directHeaders))).status).toBe(402)
+    expect((await POST(request(body, directHeaders), {})).status).toBe(402)
   })
 
   it.each([
@@ -803,24 +803,24 @@ describe('validation lifecycle purposes', () => {
       isExceeded: true,
       reason: 'usage_unavailable',
     })
-    expect((await POST(request(body, paidHeaders))).status).toBe(200)
+    expect((await POST(request(body, paidHeaders), {})).status).toBe(200)
     mockCheckAttributedUsageLimits.mockRejectedValue(new Error('ledger read timed out'))
-    expect((await POST(request(body, paidHeaders))).status).toBe(200)
+    expect((await POST(request(body, paidHeaders), {})).status).toBe(200)
   })
 
   it('refuses a free payer polled continuation whose spend cannot be read, with the usage card', async () => {
     mockCheckAttributedUsageLimits.mockResolvedValue({
       isExceeded: true,
       reason: 'usage_unavailable',
     })
-    const unavailable = await POST(request(body, attributedHeaders))
+    const unavailable = await POST(request(body, attributedHeaders), {})
     expect(unavailable.status).toBe(402)
     await expect(unavailable.json()).resolves.toMatchObject({
       code: 'USAGE_LIMIT_EXCEEDED',
       usageUpgrade: { action: 'upgrade_plan' },
     })
     mockCheckAttributedUsageLimits.mockRejectedValue(new Error('ledger read timed out'))
-    expect((await POST(request(body, attributedHeaders))).status).toBe(402)
+    expect((await POST(request(body, attributedHeaders), {})).status).toBe(402)
   })
 
   it('refuses a continuation over its usage limit with the card the worker writes', async () => {

apps/sim/app/api/copilot/api-keys/validate/route.ts

@@ -466,7 +466,9 @@ export const POST = withRouteHandler((req: NextRequest) =>
                 ? billing.attribution
                 : verdict?.status === 'exceeded'
                   ? verdict.payer
-                  : undefined,
+                  : billing
+                    ? { billingEntity: billing.decision.billingEntity, payerSubscription: null }
+                    : undefined,
               verdict?.status === 'exceeded' ? verdict.scope : undefined
             )
             return NextResponse.json<ValidateCopilotApiKeyUsageExceeded>(

apps/sim/lib/billing/core/mid-run-usage.ts

@@ -217,8 +217,8 @@ const accountVerdictCache = new LRUCache<string, MidRunUsageVerdict>({
  * payer, in the gate's order: a blocked actor or payer first, then the payer's spend. The payer
  * is the one saved in the decision at admission, never re-selected from the actor's current
  * memberships, and the period judged is the one its charges land in, as for attributed runs.
- * Whether {@link MidRunUsageReadOptions.uncachedForFreePayer} applies is judged by the payer's
- * current subscription.
+ * Whether {@link MidRunUsageReadOptions.uncachedForFreePayer} applies is judged by the plan the
+ * run was admitted with, as {@link isFreeRunPayer} judges it.
  */
 export async function readMidRunAccountUsageVerdict(
   decision: AccountBillingDecision,
@@ -253,7 +253,7 @@ export async function readMidRunAccountUsageVerdict(
       subscription?.status ?? '',
       subscription?.seats ?? '',
     ].join(':')
-    const uncached = options.uncachedForFreePayer === true && isFree(subscription?.plan)
+    const uncached = options.uncachedForFreePayer === true && isFreeRunPayer(decision)
     const cached = uncached ? undefined : accountVerdictCache.get(key)
     if (cached) return cached
     const block = await checkAccountBillingBlocks(decision)

apps/sim/lib/compare/data/sim.ts

@@ -1152,7 +1152,7 @@ export const simProfile: CompetitorProfile = {
       },
       executionLimits: {
         value:
-          'Plan-gated: synchronous runs time out at 5 minutes on the free plan and 50 minutes on paid plans; async runs default to 90 minutes, while Enterprise policy can be configured up to 7 days; concurrency ranges from 10 to 1,000 executions per billing account depending on plan',
+          'Plan-gated: synchronous runs time out at 5 minutes on the free plan and 50 minutes on paid plans; async runs default to 90 minutes, while Enterprise policy can be configured up to 7 days; concurrency ranges from 2 to 1,000 executions per billing account depending on plan',
         detail:
           'A direct async API request can shorten the account policy for that request, but cannot extend it. Concurrency limits are published in the platform cost docs, where the Enterprise limit is 1,000 by default and customizable. A run that exceeds its time limit is terminated and marked failed with a timeout error.',
         shortValue: '5-50 min sync; async defaults to 90 min, Enterprise up to 7 days',

apps/sim/providers/run-usage-limit.test.ts

@@ -2,6 +2,10 @@
  * @vitest-environment node
  */
 import { resetEnvFlagsMock, setEnvFlags } from '@sim/testing'
+import {
+  billingAttributionMock,
+  billingAttributionMockFns,
+} from '@sim/testing/mocks/billing-attribution.mock'
 import { billingCoreMock } from '@sim/testing/mocks/billing-core.mock'
 import {
   billingUsageGateCacheMock,
@@ -17,6 +21,7 @@ vi.mock('@/providers/registry', () => ({
   getProviderExecutor: async () => ({ executeRequest: mockExecuteRequest }),
 }))
 vi.mock('@/lib/billing/core/usage-gate-cache', () => billingUsageGateCacheMock)
+vi.mock('@/lib/billing/core/attribution', () => billingAttributionMock)
 vi.mock('@/tools', () => toolsMock)
 vi.mock('@/lib/billing/core/billing', () => billingCoreMock)
 vi.mock('@/providers/cost-policy', async (importOriginal) => ({
@@ -60,6 +65,7 @@ import { providerFailureLogLevel } from '@/providers/streaming-tool-loop-shared'
 import { ProviderError, type ProviderRequest, type ProviderToolConfig } from '@/providers/types'
 
 const { mockCheckExecutionUsageLimits } = billingUsageGateCacheMockFns
+const { mockCheckAttributedUsageLimits } = billingAttributionMockFns
 const { mockExecuteTool } = toolsMockFns
 
 const attribution: BillingAttributionSnapshot = {
@@ -105,6 +111,11 @@ async function modelStep(request: ProviderRequest, input: number, output: number
 beforeEach(() => {
   setEnvFlags({ isHosted: true, isBillingEnabled: true })
   mockCheckExecutionUsageLimits.mockReset()
+  // A free payer's mid-run read skips the cached gate; both answer from the same ledger.
+  mockCheckAttributedUsageLimits.mockReset()
+  mockCheckAttributedUsageLimits.mockImplementation((attribution) =>
+    mockCheckExecutionUsageLimits(attribution)
+  )
   mockCheckExecutionUsageLimits.mockResolvedValue({
     isExceeded: false,
     payerUsage: { currentUsage: 3, limit: 5 },

apps/sim/providers/run-usage-limit.ts

@@ -67,7 +67,7 @@ export function recordModelStepCost(
  * and a free plan's spend past its limit is never billed. A paid payer's overshoot is billed as
  * overage, so its runs are left to admission and never read here.
  *
- * Reads nothing until the run has spent, then the cached execution gate. A gate that cannot
+ * Reads nothing until the run has spent, then the payer's ledger. A gate that cannot
  * answer stops the run as if the limit were spent. A blocked account lets the run continue and
  * is not read again for {@link NEAR_LIMIT_USAGE_GATE_TTL_MS}: the next admission refuses it with
  * blocked-account copy rather than the upgrade card. The stop is not retried,
@@ -92,7 +92,9 @@ export async function assertRunWithinUsageLimit(
     return
   }
 
-  const verdict = await readMidRunUsageVerdict(attribution, unrecorded.total)
+  const verdict = await readMidRunUsageVerdict(attribution, unrecorded.total, {
+    uncachedForFreePayer: true,
+  })
   // A run cancelled during the read keeps its cancellation; the provider call then aborts.
   if (verdict.status === 'within' || executionContext.abortSignal?.aborted) return
   if (verdict.status === 'blocked') {