fix(billing): keep an exceeded verdict when the upgrade-card read is slow

The shared deadline discarded an exceeded verdict when the card lookup ran
past the budget. The verdict read keeps the deadline; the card lookup now
falls back to the plan-upgrade card past the same deadline.

Author: waleedlatif1

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

@@ -1051,16 +1051,20 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
       expect(body.usageExceeded).toBe(false)
     })
 
-    it('answers not exceeded when the upgrade-card read outlasts the callback budget', async () => {
+    it('keeps the exceeded verdict with the plan-upgrade card when the card read outlasts the callback budget', async () => {
       billingPlanMockFns.mockGetHighestPrioritySubscription.mockImplementation(async () => {
         await sleep(1500)
-        return null
+        return { plan: 'pro' }
       })
       const startedAt = Date.now()
 
       const body = await (await POST(directCallback())).json()
 
-      expect(body).toMatchObject({ success: true, usageExceeded: false })
+      expect(body).toMatchObject({
+        success: true,
+        usageExceeded: true,
+        usageUpgrade: { action: 'upgrade_plan' },
+      })
       expect(Date.now() - startedAt).toBeLessThan(1400)
     })
   })

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

@@ -23,6 +23,7 @@ import {
   toBillingContext,
 } from '@/lib/billing/core/billing-attribution'
 import {
+  type MidRunUsageVerdict,
   readMidRunAccountUsageVerdict,
   readMidRunUsageVerdict,
 } from '@/lib/billing/core/mid-run-usage'
@@ -84,8 +85,8 @@ function invalidBillingProtocolResponse(requestId: string, span: Span): NextResp
  * steady-state steps cost no ledger read. The charge is
  * already recorded when this runs; a gate that cannot answer reports not-exceeded and leaves the
  * refusal to the next step or re-check rather than ending a paying run on a database blip,
- * and so does a read, verdict and upgrade card together, that outlasts
- * {@link USAGE_STANDING_TIMEOUT_MS}.
+ * and so does a verdict read that outlasts {@link USAGE_STANDING_TIMEOUT_MS}. An exceeded
+ * verdict always pauses the run; a card read past that budget falls back to the plan-upgrade card.
  */
 async function readUsageStanding(
   userId: string,
@@ -98,22 +99,26 @@ async function readUsageStanding(
       ? () => readMidRunAccountUsageVerdict(accountDecision)
       : null
   if (!isHosted || !readVerdict) return { usageExceeded: false }
-  const readStanding = async (): Promise<BillingUsageVerdict> => {
-    const verdict = await readVerdict()
-    // Only a spent limit pauses the run. A blocked account is refused at the run's next
-    // continuation or re-check, with blocked-account copy rather than the upgrade card.
-    if (verdict.status !== 'exceeded') return { usageExceeded: false }
-    return {
-      usageExceeded: true,
-      usageUpgrade: await resolveUsageUpgradePayload(userId, billingAttribution, verdict.scope),
-    }
-  }
+  const deadlineAt = Date.now() + USAGE_STANDING_TIMEOUT_MS
+  let verdict: MidRunUsageVerdict
   try {
-    return await withinDeadline(readStanding, Date.now() + USAGE_STANDING_TIMEOUT_MS)
+    verdict = await withinDeadline(readVerdict, deadlineAt)
   } catch {
     logger.warn('Usage standing read outlasted the callback budget; answering not exceeded')
     return { usageExceeded: false }
   }
+  // Only a spent limit pauses the run. A blocked account is refused at the run's next
+  // continuation or re-check, with blocked-account copy rather than the upgrade card.
+  if (verdict.status !== 'exceeded') return { usageExceeded: false }
+  return {
+    usageExceeded: true,
+    usageUpgrade: await resolveUsageUpgradePayload(
+      userId,
+      billingAttribution,
+      verdict.scope,
+      deadlineAt
+    ),
+  }
 }
 
 function getBillingResolution(

apps/sim/lib/billing/usage-upgrade.ts

@@ -8,6 +8,7 @@ import type {
 import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
 import { isEnterprise, isPaid } from '@/lib/billing/plan-helpers'
 import { isOrgScopedSubscription } from '@/lib/billing/subscriptions/utils'
+import { withinDeadline } from '@/lib/core/utils/deadline'
 
 const logger = createLogger('UsageUpgrade')
 
@@ -22,12 +23,14 @@ const MEMBER_CAP_MESSAGE =
  * increase for a paid one, with copy naming who can raise an organization's limit. A member
  * over the cap their organization set gets copy naming who can raise that cap. An attributed
  * run reads the plan from its admission snapshot without a query; otherwise the actor's current
- * subscription decides, and a failed lookup falls back to the plan-upgrade card.
+ * subscription decides, and a lookup that fails or outlasts `deadlineAt` falls back to the
+ * plan-upgrade card.
  */
 export async function resolveUsageUpgradePayload(
   userId: string,
   billingAttribution?: BillingAttributionSnapshot,
-  scope?: AttributedUsageLimitsResult['scope']
+  scope?: AttributedUsageLimitsResult['scope'],
+  deadlineAt?: number
 ): Promise<UsageUpgradePayload> {
   if (scope === 'member') {
     return { reason: 'usage_limit', action: 'increase_limit', message: MEMBER_CAP_MESSAGE }
@@ -39,7 +42,9 @@ export async function resolveUsageUpgradePayload(
       plan = billingAttribution.payerSubscription?.plan
       orgScoped = billingAttribution.billingEntity.type === 'organization'
     } else {
-      const subscription = await getHighestPrioritySubscription(userId)
+      const subscription = await (deadlineAt === undefined
+        ? getHighestPrioritySubscription(userId)
+        : withinDeadline(() => getHighestPrioritySubscription(userId), deadlineAt))
       plan = subscription?.plan
       orgScoped = isOrgScopedSubscription(subscription, userId)
     }