fix(billing): settle into the payer's current period and cancel on trusted fal URLs

Author: waleedlatif1

apps/sim/lib/internal/image/operations.test.ts

@@ -130,7 +130,7 @@ describe('image operations', () => {
     expect(mockUploadCopilotFile).not.toHaveBeenCalled()
   })
 
-  it('rejects foreign fal queue hosts before sending credentials', async () => {
+  it('rejects foreign fal queue hosts before sending credentials and cancels on the fal queue', async () => {
     mocks.fetch.mockResolvedValueOnce(
       Response.json({
         request_id: 'foreign-job',
@@ -147,6 +147,10 @@ describe('image operations', () => {
     expect(response.status).toBe(500)
     expect(await response.json()).toMatchObject({ error: 'Invalid Fal.ai queue URL' })
     expect(mockSecureFetchWithPinnedIP).not.toHaveBeenCalled()
+    expect(mocks.fetch).toHaveBeenLastCalledWith(
+      expect.stringMatching(/^https:\/\/queue\.fal\.run\/.+\/requests\/foreign-job\/cancel$/),
+      expect.objectContaining({ method: 'PUT' })
+    )
   })
 
   it('retrieves nested fal jobs from the documented application request path', async () => {

apps/sim/lib/internal/image/operations.ts

@@ -457,24 +457,22 @@ async function generateWithFalAI(
     throw new Error('Fal.ai queue response missing request_id')
   }
 
-  const statusUrl = falQueueUrl(
-    getStringProperty(createData, 'status_url') ||
-      buildFalAIQueueUrl(endpoint, falRequestId, 'status')
-  )
-  const responseUrl = falQueueUrl(
-    getStringProperty(createData, 'response_url') ||
-      buildFalAIQueueUrl(endpoint, falRequestId, 'response')
-  )
-
-  const cancelUrl = falQueueUrl(
-    getStringProperty(createData, 'cancel_url') ||
-      `${buildFalAIQueueUrl(endpoint, falRequestId, 'response')}/cancel`
-  )
+  /** Built from the endpoint, never a provider URL, so a rejected one can still be cancelled. */
+  const cancelUrl = `${buildFalAIQueueUrl(endpoint, falRequestId, 'response')}/cancel`
 
   logger.info('Fal.ai image request created', { requestId, falRequestId })
 
   let reachedTerminalStatus = false
   try {
+    const statusUrl = falQueueUrl(
+      getStringProperty(createData, 'status_url') ||
+        buildFalAIQueueUrl(endpoint, falRequestId, 'status')
+    )
+    const responseUrl = falQueueUrl(
+      getStringProperty(createData, 'response_url') ||
+        buildFalAIQueueUrl(endpoint, falRequestId, 'response')
+    )
+
     const statusValidation = await validateUrlWithDNS(statusUrl, 'statusUrl', 'contentFetch')
     if (!statusValidation.isValid) {
       throw new Error(statusValidation.error)

apps/sim/lib/internal/video/client.ts

@@ -393,19 +393,18 @@ async function generateWithFalAI(
 
   const app = endpoint.split('/', 2).join('/')
   const requestUrl = `https://queue.fal.run/${app}/requests/${encodeURIComponent(requestIdFal)}`
-  const statusUrl = falQueueUrl(
-    getStringProperty(createData, 'status_url') || `${requestUrl}/status`
-  )
-  const responseUrl = falQueueUrl(getStringProperty(createData, 'response_url') || requestUrl)
-
-  const cancelUrl = falQueueUrl(
-    getStringProperty(createData, 'cancel_url') || `${requestUrl}/cancel`
-  )
+  /** Built from the endpoint, never a provider URL, so a rejected one can still be cancelled. */
+  const cancelUrl = `${requestUrl}/cancel`
 
   logger.info(`Fal.ai request created: ${requestIdFal}`, { requestId })
 
   let reachedTerminalStatus = false
   try {
+    const statusUrl = falQueueUrl(
+      getStringProperty(createData, 'status_url') || `${requestUrl}/status`
+    )
+    const responseUrl = falQueueUrl(getStringProperty(createData, 'response_url') || requestUrl)
+
     const maxAttempts = Math.ceil(getMaxExecutionTimeout() / POLL_INTERVAL_MS)
     let attempts = 0
 

apps/sim/lib/tools/falai-settlement.integration.ts

@@ -29,7 +29,11 @@ async function createUser(): Promise<string> {
   return id
 }
 
-function payloadFor(userId: string, billedProviderCostDollars: number): FalAICostSettlementPayload {
+function payloadFor(
+  userId: string,
+  billedProviderCostDollars: number,
+  billingPeriod = { start: '2026-11-01T00:00:00.000Z', end: '2026-12-01T00:00:00.000Z' }
+): FalAICostSettlementPayload {
   return {
     envVarName: HOSTED_KEY_ENV_VAR,
     endpointId: 'bytedance/seedance-2.5/text-to-video',
@@ -38,10 +42,15 @@ function payloadFor(userId: string, billedProviderCostDollars: number): FalAICos
     markupMultiplier: 1.5,
     ledger: {
       source: 'workflow',
-      userId,
-      workspaceId: null,
-      billingEntity: { type: 'user', id: userId },
-      billingPeriod: { start: '2026-11-01T00:00:00.000Z', end: '2026-12-01T00:00:00.000Z' },
+      billingAttribution: {
+        actorUserId: userId,
+        workspaceId: null,
+        organizationId: null,
+        billedAccountUserId: userId,
+        billingEntity: { type: 'user', id: userId },
+        billingPeriod,
+        payerSubscription: null,
+      },
     },
   }
 }
@@ -70,7 +79,12 @@ function stubFalBillingEvents(charge: { requestId: string; costDollars: number }
 
 async function settlementRows(userId: string) {
   return db
-    .select({ cost: usageLog.cost, description: usageLog.description, source: usageLog.source })
+    .select({
+      cost: usageLog.cost,
+      description: usageLog.description,
+      source: usageLog.source,
+      billingPeriodEnd: usageLog.billingPeriodEnd,
+    })
     .from(usageLog)
     .where(eq(usageLog.userId, userId))
 }
@@ -109,6 +123,19 @@ describe('settleFalAICost', () => {
     })
   })
 
+  it('bills a settlement that outlives its billing period to the payer current period', async () => {
+    const userId = await createUser()
+    const endedPeriod = { start: '2026-01-01T00:00:00.000Z', end: '2026-02-01T00:00:00.000Z' }
+    const payload = payloadFor(userId, 6.49, endedPeriod)
+    stubFalBillingEvents({ requestId: payload.requestId, costDollars: 15 })
+
+    expect(await settleFalAICost(payload)).toBe('charged')
+
+    const rows = await settlementRows(userId)
+    expect(rows).toHaveLength(1)
+    expect(rows[0].billingPeriodEnd?.getTime()).toBeGreaterThan(Date.now())
+  })
+
   it('bills nothing while fal has not recorded the charge', async () => {
     const userId = await createUser()
     stubFalBillingEvents(null)

apps/sim/lib/tools/falai-settlement.ts

@@ -1,8 +1,11 @@
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { tasks } from '@trigger.dev/sdk'
-import type { BillingAttributionSnapshot } from '@/lib/billing/core/attribution'
-import { type BillingEntity, recordUsage, stableEventKey } from '@/lib/billing/core/usage-log'
+import {
+  type BillingAttributionSnapshot,
+  refreshAttributionPeriod,
+} from '@/lib/billing/core/attribution'
+import { recordUsage, stableEventKey } from '@/lib/billing/core/usage-log'
 import { resolveTriggerRegion } from '@/lib/core/async-jobs/region'
 import { env } from '@/lib/core/config/env'
 import { isBillingEnabled, isHosted, isTriggerDevEnabled } from '@/lib/core/config/env-flags'
@@ -34,12 +37,10 @@ export interface FalAICostSettlementPayload {
   markupMultiplier: number
   ledger: {
     source: FalAISettlementSource
-    userId: string
-    workspaceId: string | null
     workflowId?: string
     executionId?: string
-    billingEntity: BillingEntity
-    billingPeriod: { start: string; end: string }
+    /** The run's payer as admitted; its period is refreshed when settlement outlives it. */
+    billingAttribution: BillingAttributionSnapshot
   }
 }
 
@@ -85,15 +86,9 @@ export async function scheduleFalAICostSettlement(
     markupMultiplier: params.markupMultiplier,
     ledger: {
       source: params.source,
-      userId: billingAttribution.actorUserId,
-      workspaceId: billingAttribution.workspaceId,
       workflowId: params.workflowId,
       executionId: params.executionId,
-      billingEntity: { ...billingAttribution.billingEntity },
-      billingPeriod: {
-        start: billingAttribution.billingPeriod.start,
-        end: billingAttribution.billingPeriod.end,
-      },
+      billingAttribution,
     },
   }
 
@@ -116,6 +111,8 @@ export async function scheduleFalAICostSettlement(
  * Bills the difference between fal's exact charge for a request and the estimate billed at
  * completion. The ledger row's event key is the request, so a retried settlement never bills
  * twice. An estimate above the exact charge is left as billed: the ledger records charges only.
+ * A settlement that outlives the run's billing period bills the payer's current period, since
+ * the ended one may already be closed and invoiced.
  */
 export async function settleFalAICost(
   payload: FalAICostSettlementPayload
@@ -139,15 +136,19 @@ export async function settleFalAICost(
   }
   if (shortfallDollars === 0) return 'exact'
 
+  const attribution =
+    Date.parse(ledger.billingAttribution.billingPeriod.end) <= Date.now()
+      ? await refreshAttributionPeriod(ledger.billingAttribution)
+      : ledger.billingAttribution
   await recordUsage({
-    userId: ledger.userId,
-    workspaceId: ledger.workspaceId ?? undefined,
+    userId: attribution.actorUserId,
+    workspaceId: attribution.workspaceId ?? undefined,
     workflowId: ledger.workflowId,
     executionId: ledger.executionId,
-    billingEntity: ledger.billingEntity,
+    billingEntity: { ...attribution.billingEntity },
     billingPeriod: {
-      start: new Date(ledger.billingPeriod.start),
-      end: new Date(ledger.billingPeriod.end),
+      start: new Date(attribution.billingPeriod.start),
+      end: new Date(attribution.billingPeriod.end),
     },
     entries: [
       {