feat(billing): record function sandbox usage

Author: Bill Leoutsakos

apps/sim/app/api/webhooks/outbox/process/route.ts

@@ -8,6 +8,7 @@ import { verifyCronAuth } from '@/lib/auth/internal'
 import { enterpriseOwnerClaimOutboxHandlers } from '@/lib/billing/enterprise-owner-claim'
 import { enterpriseIssuanceOutboxHandlers } from '@/lib/billing/enterprise-provisioning'
 import { membershipBillingOutboxHandlers } from '@/lib/billing/organizations/membership-reconciliation'
+import { sandboxUsageOutboxHandlers } from '@/lib/billing/sandbox-usage-outbox'
 import { billingOutboxHandlers } from '@/lib/billing/webhooks/outbox-handlers'
 import { processOutboxEvents } from '@/lib/core/outbox/service'
 import { generateRequestId } from '@/lib/core/utils/request'
@@ -29,6 +30,7 @@ const handlers = {
   ...adminMemberOperationOutboxHandlers,
   ...billingOutboxHandlers,
   ...membershipBillingOutboxHandlers,
+  ...sandboxUsageOutboxHandlers,
   ...enterpriseIssuanceOutboxHandlers,
   ...enterpriseOwnerClaimOutboxHandlers,
   ...invitationMigrationOutboxHandlers,

apps/sim/lib/billing/core/usage-log.test.ts

@@ -86,7 +86,7 @@ describe('recordUsage', () => {
   })
 
   it('commits canonical usage rows with deterministic event keys and billing scope', async () => {
-    await recordUsage({
+    const insertedCost = await recordUsage({
       userId: 'external-actor',
       workspaceId: 'workspace-1',
       billingEntity: { type: 'organization', id: 'workspace-org' },
@@ -124,9 +124,34 @@ describe('recordUsage', () => {
     expect(mockOnConflictDoNothing.mock.calls[0][0]).toMatchObject({
       target: usageLog.eventKey,
     })
+    expect(insertedCost).toBeCloseTo(0.3, 8)
     expect(mockGetHighestPrioritySubscription).not.toHaveBeenCalled()
   })
 
+  it('returns zero when idempotency skips a duplicate event', async () => {
+    mockReturning.mockResolvedValueOnce([])
+
+    const insertedCost = await recordUsage({
+      userId: 'user-1',
+      billingEntity: { type: 'user', id: 'user-1' },
+      billingPeriod: {
+        start: new Date('2026-05-01T00:00:00.000Z'),
+        end: new Date('2026-06-01T00:00:00.000Z'),
+      },
+      entries: [
+        {
+          category: 'tool',
+          source: 'workflow',
+          description: 'Code sandbox',
+          cost: 0.1,
+          eventKey: 'sandbox-event',
+        },
+      ],
+    })
+
+    expect(insertedCost).toBe(0)
+  })
+
   it('uses pre-resolved billing context without loading subscriptions', async () => {
     await recordUsage({
       userId: 'user-1',

apps/sim/lib/billing/core/usage-log.ts

@@ -417,7 +417,7 @@ export async function getStampedPeriodRangeUsageCostByUser(
  * as the pre-cutover period baseline and for low-frequency billing trackers,
  * but usage writes no longer contend on the user_stats row.
  */
-export async function recordUsage(params: RecordUsageParams): Promise<void> {
+export async function recordUsage(params: RecordUsageParams): Promise<number> {
   // The usage ledger is written regardless of BILLING_ENABLED so it is the
   // single, universal source of truth for cost (including self-hosted, where
   // it powers the logs-page cost display). Billing *enforcement* (Stripe /
@@ -441,7 +441,7 @@ export async function recordUsage(params: RecordUsageParams): Promise<void> {
   )
 
   if (validEntries.length === 0) {
-    return
+    return 0
   }
 
   if (workspaceId && (!billingEntity || !billingPeriod)) {
@@ -514,6 +514,8 @@ export async function recordUsage(params: RecordUsageParams): Promise<void> {
     entryCount: validEntries.length,
     sources: [...new Set(validEntries.map((e) => e.source))],
   })
+
+  return insertedCost
 }
 
 /**

apps/sim/lib/billing/sandbox-pricing.test.ts

@@ -0,0 +1,51 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createSandboxPricingSnapshot, priceSandboxUsage } from '@/lib/billing/sandbox-pricing'
+
+const STARTED_AT = new Date('2026-08-27T12:00:00.000Z')
+const ONE_HOUR_LATER = new Date('2026-08-27T13:00:00.000Z')
+
+describe('sandbox pricing', () => {
+  it.each([
+    ['e2b', 0.1656],
+    ['daytona', 0.16668],
+  ] as const)('prices one hour of the %s Function profile', (provider, expectedRawCost) => {
+    const priced = priceSandboxUsage(
+      createSandboxPricingSnapshot(provider, 1),
+      STARTED_AT,
+      ONE_HOUR_LATER,
+      ONE_HOUR_LATER
+    )
+
+    expect(priced.durationMs).toBe(3_600_000)
+    expect(priced.rawCost).toBeCloseTo(expectedRawCost, 10)
+    expect(priced.billedCost).toBe(expectedRawCost)
+  })
+
+  it('applies the multiplier once and rounds to eight decimals', () => {
+    const priced = priceSandboxUsage(
+      createSandboxPricingSnapshot('e2b', 2.5),
+      STARTED_AT,
+      new Date(STARTED_AT.getTime() + 1234),
+      ONE_HOUR_LATER
+    )
+
+    expect(priced.billedCost).toBe(Number.parseFloat((priced.rawCost * 2.5).toFixed(8)))
+  })
+
+  it('caps duration at provider expiry and rejects a non-positive multiplier', () => {
+    const expiresAt = new Date(STARTED_AT.getTime() + 15_000)
+    const priced = priceSandboxUsage(
+      createSandboxPricingSnapshot('daytona', 1),
+      STARTED_AT,
+      ONE_HOUR_LATER,
+      expiresAt
+    )
+
+    expect(priced.durationMs).toBe(15_000)
+    expect(() => createSandboxPricingSnapshot('e2b', 0)).toThrow('finite positive')
+  })
+})

apps/sim/lib/billing/sandbox-pricing.ts

@@ -0,0 +1,157 @@
+import { getCostMultiplier } from '@/lib/core/config/env-flags'
+import {
+  FUNCTION_DAYTONA_DISK_GB,
+  FUNCTION_SANDBOX_CPU_COUNT,
+  FUNCTION_SANDBOX_MEMORY_GB,
+} from '@/lib/execution/remote-sandbox/function-resources'
+import type { SandboxProviderId } from '@/lib/execution/remote-sandbox/types'
+
+const PRICING_V1_VERIFIED_AT = '2026-08-27' as const
+const E2B_CPU_USD_PER_VCPU_SECOND = 0.000014
+const E2B_MEMORY_USD_PER_GIB_SECOND = 0.0000045
+const DAYTONA_CPU_USD_PER_VCPU_SECOND = 0.0504 / 3600
+const DAYTONA_MEMORY_USD_PER_GIB_SECOND = 0.0162 / 3600
+const DAYTONA_DISK_USD_PER_GIB_SECOND = 0.000108 / 3600
+export interface SandboxResourceProfile {
+  vcpu: number
+  memoryGiB: number
+  diskGiB: number
+}
+
+export interface SandboxUnitRates {
+  cpuUsdPerVcpuSecond: number
+  memoryUsdPerGiBSecond: number
+  diskUsdPerGiBSecond: number
+}
+
+export interface SandboxPricingSnapshot {
+  version: 1
+  provider: SandboxProviderId
+  verifiedAt: typeof PRICING_V1_VERIFIED_AT
+  multiplier: number
+  resources: SandboxResourceProfile
+  rates: SandboxUnitRates
+}
+
+export interface PricedSandboxUsage {
+  durationMs: number
+  sandboxSeconds: number
+  vcpuSeconds: number
+  memoryGiBSeconds: number
+  diskGiBSeconds: number
+  rawCost: number
+  billedCost: number
+}
+
+const PRICING_BY_PROVIDER: Record<
+  SandboxProviderId,
+  Pick<SandboxPricingSnapshot, 'resources' | 'rates'>
+> = {
+  e2b: {
+    resources: {
+      vcpu: FUNCTION_SANDBOX_CPU_COUNT,
+      memoryGiB: FUNCTION_SANDBOX_MEMORY_GB,
+      diskGiB: 0,
+    },
+    rates: {
+      cpuUsdPerVcpuSecond: E2B_CPU_USD_PER_VCPU_SECOND,
+      memoryUsdPerGiBSecond: E2B_MEMORY_USD_PER_GIB_SECOND,
+      diskUsdPerGiBSecond: 0,
+    },
+  },
+  daytona: {
+    resources: {
+      vcpu: FUNCTION_SANDBOX_CPU_COUNT,
+      memoryGiB: FUNCTION_SANDBOX_MEMORY_GB,
+      diskGiB: FUNCTION_DAYTONA_DISK_GB,
+    },
+    rates: {
+      cpuUsdPerVcpuSecond: DAYTONA_CPU_USD_PER_VCPU_SECOND,
+      memoryUsdPerGiBSecond: DAYTONA_MEMORY_USD_PER_GIB_SECOND,
+      diskUsdPerGiBSecond: DAYTONA_DISK_USD_PER_GIB_SECOND,
+    },
+  },
+}
+
+function assertFiniteNonNegative(value: number, field: string): void {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`Sandbox pricing ${field} must be a finite non-negative number`)
+  }
+}
+
+function assertFinitePositive(value: number, field: string): void {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`Sandbox pricing ${field} must be a finite positive number`)
+  }
+}
+
+export function createSandboxPricingSnapshot(
+  provider: SandboxProviderId,
+  multiplier = getCostMultiplier()
+): SandboxPricingSnapshot {
+  assertFinitePositive(multiplier, 'multiplier')
+  const pricing = PRICING_BY_PROVIDER[provider]
+  return {
+    version: 1,
+    provider,
+    verifiedAt: PRICING_V1_VERIFIED_AT,
+    multiplier,
+    resources: { ...pricing.resources },
+    rates: { ...pricing.rates },
+  }
+}
+
+export function assertSandboxPricingSnapshot(value: unknown): SandboxPricingSnapshot {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Sandbox pricing snapshot must be an object')
+  }
+  const snapshot = value as Partial<SandboxPricingSnapshot>
+  if (
+    snapshot.version !== 1 ||
+    (snapshot.provider !== 'e2b' && snapshot.provider !== 'daytona') ||
+    snapshot.verifiedAt !== PRICING_V1_VERIFIED_AT ||
+    !snapshot.resources ||
+    !snapshot.rates
+  ) {
+    throw new Error('Sandbox pricing snapshot is invalid')
+  }
+  assertFinitePositive(snapshot.multiplier ?? Number.NaN, 'multiplier')
+  assertFiniteNonNegative(snapshot.resources.vcpu, 'resources.vcpu')
+  assertFiniteNonNegative(snapshot.resources.memoryGiB, 'resources.memoryGiB')
+  assertFiniteNonNegative(snapshot.resources.diskGiB, 'resources.diskGiB')
+  assertFiniteNonNegative(snapshot.rates.cpuUsdPerVcpuSecond, 'rates.cpuUsdPerVcpuSecond')
+  assertFiniteNonNegative(snapshot.rates.memoryUsdPerGiBSecond, 'rates.memoryUsdPerGiBSecond')
+  assertFiniteNonNegative(snapshot.rates.diskUsdPerGiBSecond, 'rates.diskUsdPerGiBSecond')
+  return snapshot as SandboxPricingSnapshot
+}
+
+export function priceSandboxUsage(
+  pricingValue: SandboxPricingSnapshot,
+  startedAt: Date,
+  endedAt: Date,
+  expiresAt: Date
+): PricedSandboxUsage {
+  const pricing = assertSandboxPricingSnapshot(pricingValue)
+  const durationMs = Math.max(
+    0,
+    Math.min(endedAt.getTime(), expiresAt.getTime()) - startedAt.getTime()
+  )
+  const sandboxSeconds = durationMs / 1000
+  const vcpuSeconds = sandboxSeconds * pricing.resources.vcpu
+  const memoryGiBSeconds = sandboxSeconds * pricing.resources.memoryGiB
+  const diskGiBSeconds = sandboxSeconds * pricing.resources.diskGiB
+  const rawCost =
+    vcpuSeconds * pricing.rates.cpuUsdPerVcpuSecond +
+    memoryGiBSeconds * pricing.rates.memoryUsdPerGiBSecond +
+    diskGiBSeconds * pricing.rates.diskUsdPerGiBSecond
+
+  return {
+    durationMs,
+    sandboxSeconds,
+    vcpuSeconds,
+    memoryGiBSeconds,
+    diskGiBSeconds,
+    rawCost,
+    billedCost: Number.parseFloat((rawCost * pricing.multiplier).toFixed(8)),
+  }
+}