refactor(providers): drop unreachable billing fallbacks

Every provider pricing helper took a policy parameter no caller passed. Worse
than dead: passing one would have double-applied the margin the central layer
already applies. Removed, so providers can only price at list.

Also removed guards that cannot fire. The central fallback normalized cache
buckets no provider can reach it with (all three that report cache usage price
themselves) and did so at a 1x write multiplier no vendor charges.
priceModelUsage re-validated token counts the adapter had already clamped, and
applyModelCostPolicy defaulted a required total field.

Validation now happens once, in the adapter that parses the vendor payload and
is the only layer that knows cache buckets are a subset of the prompt total.

Author: icecrasher321

apps/sim/providers/anthropic/usage.ts

@@ -1,10 +1,5 @@
 import type { BlockTokens } from '@/executor/types'
-import {
-  LIST_PRICE_POLICY,
-  type ModelCostPolicy,
-  type ModelUsage,
-  priceModelUsage,
-} from '@/providers/cost-policy'
+import { LIST_PRICE_POLICY, type ModelUsage, priceModelUsage } from '@/providers/cost-policy'
 import type { ModelPricing } from '@/providers/types'
 
 export interface AnthropicUsageLike {
@@ -128,14 +123,17 @@ export function buildAnthropicModelUsage(accumulator: AnthropicUsageAccumulator)
 /**
  * Prices one Anthropic request, cache tiers included, through the shared
  * pricing function.
+ *
+ * Always at list price. Billability and the margin are applied once, centrally,
+ * by `executeProviderRequest` — a provider applying them here would double-count
+ * the multiplier.
  */
 export function buildAnthropicUsageCost(
   model: string,
   accumulator: AnthropicUsageAccumulator,
-  toolCost = 0,
-  policy: ModelCostPolicy = LIST_PRICE_POLICY
+  toolCost = 0
 ): AnthropicUsageCost {
-  const cost = priceModelUsage(model, buildAnthropicModelUsage(accumulator), policy)
+  const cost = priceModelUsage(model, buildAnthropicModelUsage(accumulator), LIST_PRICE_POLICY)
 
   return {
     input: cost.input,

apps/sim/providers/cost-policy.test.ts

@@ -133,21 +133,6 @@ describe('priceModelUsage', () => {
     expect(cost).toMatchObject({ input: 0, output: 0, total: 0 })
   })
 
-  it('ignores negative and non-finite token counts rather than crediting the run', () => {
-    const cost = priceModelUsage(
-      PRICED_MODEL,
-      {
-        input: 1000,
-        output: 0,
-        cacheRead: -5000,
-        cacheWrites: [{ tokens: 1000, inputRateMultiplier: Number.NaN }],
-      },
-      LIST_PRICE_POLICY
-    )
-
-    expect(cost.input).toBeCloseTo(1000 * PER_TOKEN_INPUT, 8)
-  })
-
   /**
    * The regression this guards: Anthropic reports `input_tokens` already
    * excluding cache tokens while OpenAI and Gemini report a cached subset of

apps/sim/providers/cost-policy.ts

@@ -93,7 +93,7 @@ export function applyModelCostPolicy(
   cost: ModelCost | undefined,
   policy: ModelCostPolicy
 ): ModelCost {
-  const toolCost = typeof cost?.toolCost === 'number' ? cost.toolCost : 0
+  const toolCost = cost?.toolCost ?? 0
 
   if (!cost || !policy.billable) {
     return notBilledCost(toolCost)
@@ -103,7 +103,7 @@ export function applyModelCostPolicy(
     return cost
   }
 
-  const modelTotal = (cost.total ?? cost.input + cost.output) - toolCost
+  const modelTotal = cost.total - toolCost
 
   return {
     ...cost,
@@ -139,17 +139,18 @@ export interface ModelUsage {
   cacheWrites?: CacheWriteUsage[]
 }
 
-function nonNegative(value: number | undefined): number {
-  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0
-}
-
 /**
  * The single cache-aware pricing function.
  *
  * Every surface that turns tokens into a charge routes through here, so a cache
  * hit is priced identically whether it came from Anthropic, OpenAI, Gemini, or
  * an OpenAI-compatible vendor. Callers must not pre-apply the policy multiplier
  * or the cached rate themselves.
+ *
+ * Token counts are validated by the provider adapter that builds the
+ * {@link ModelUsage}, which is the only layer that knows the vendor's shape and
+ * can enforce that cache buckets are a subset of the prompt total. This function
+ * re-validates nothing.
  */
 export function priceModelUsage(
   model: string,
@@ -163,16 +164,15 @@ export function priceModelUsage(
   const multiplier = policy.multiplier
   const base = calculateCost(model, usage.input, usage.output, false, multiplier, multiplier)
 
-  const cacheRead = nonNegative(usage.cacheRead)
+  const cacheRead = usage.cacheRead ?? 0
   const read = cacheRead > 0 ? calculateCost(model, cacheRead, 0, true, multiplier, 0) : undefined
 
   let writeInputCost = 0
   for (const write of usage.cacheWrites ?? []) {
-    const tokens = nonNegative(write.tokens)
-    if (tokens === 0 || !Number.isFinite(write.inputRateMultiplier)) continue
+    if (write.tokens <= 0) continue
     writeInputCost += calculateCost(
       model,
-      tokens,
+      write.tokens,
       0,
       false,
       multiplier * write.inputRateMultiplier,
@@ -194,21 +194,19 @@ export function priceModelUsage(
 /**
  * Prices tokens for a model and applies the billing policy in one step. Use
  * wherever a caller holds raw token counts and needs the charge Sim records.
+ *
+ * Cache-free by design: a caller that has cache usage also knows its tiers, so
+ * it builds a {@link ModelUsage} and calls {@link priceModelUsage} directly.
  */
 export function calculateBillableModelCost(
   model: string,
   promptTokens = 0,
   completionTokens = 0,
-  options: { cacheRead?: number; cacheWrites?: CacheWriteUsage[]; isBYOK?: boolean } = {}
+  options: { isBYOK?: boolean } = {}
 ): PricedModelCost {
   return priceModelUsage(
     model,
-    {
-      input: promptTokens,
-      output: completionTokens,
-      cacheRead: options.cacheRead,
-      cacheWrites: options.cacheWrites,
-    },
+    { input: promptTokens, output: completionTokens },
     resolveModelCostPolicy(model, options.isBYOK)
   )
 }

apps/sim/providers/gemini/usage.ts

@@ -1,9 +1,4 @@
-import {
-  LIST_PRICE_POLICY,
-  type ModelCostPolicy,
-  type PricedModelCost,
-  priceModelUsage,
-} from '@/providers/cost-policy'
+import { LIST_PRICE_POLICY, type PricedModelCost, priceModelUsage } from '@/providers/cost-policy'
 import type { GeminiUsage } from '@/providers/gemini/types'
 
 /**
@@ -33,11 +28,13 @@ export function splitGeminiTokens(
   candidatesTokens: number,
   cachedTokens: number
 ): GeminiTokenSplit {
+  const prompt = Math.max(0, promptTokens)
   // Clamped to the prompt total: a payload reporting more cached tokens than it
   // processed would otherwise bill more input than the request contained.
-  const cacheRead = Math.min(Math.max(0, cachedTokens), Math.max(0, promptTokens))
+  const cacheRead = Math.min(Math.max(0, cachedTokens), prompt)
+
   return {
-    input: Math.max(0, promptTokens) - cacheRead,
+    input: prompt - cacheRead,
     output: candidatesTokens,
     cacheRead,
   }
@@ -55,11 +52,11 @@ export function splitGeminiUsage(usage: GeminiUsage): GeminiTokenSplit {
 /**
  * Prices a split through the shared cache-aware pricing function. With no cache
  * hit this matches pricing the whole prompt total at the base input rate.
+ *
+ * Always at list price. Billability and the margin are applied once, centrally,
+ * by `executeProviderRequest` — a provider applying them here would double-count
+ * the multiplier.
  */
-export function priceGeminiTokens(
-  model: string,
-  split: GeminiTokenSplit,
-  policy: ModelCostPolicy = LIST_PRICE_POLICY
-): PricedModelCost {
-  return priceModelUsage(model, split, policy)
+export function priceGeminiTokens(model: string, split: GeminiTokenSplit): PricedModelCost {
+  return priceModelUsage(model, split, LIST_PRICE_POLICY)
 }

apps/sim/providers/index.ts

@@ -179,27 +179,21 @@ export async function executeProviderRequest(
   const costPolicy = resolveModelCostPolicy(response.model, isBYOK)
 
   if (response.tokens) {
-    const {
-      input: promptTokens = 0,
-      output: completionTokens = 0,
-      cacheRead,
-      cacheWrite,
-    } = response.tokens
+    const { input: promptTokens = 0, output: completionTokens = 0 } = response.tokens
 
     /**
-     * A provider that priced its own usage knows cache tiers this layer cannot
-     * reconstruct from token counts alone (Anthropic's 5m vs 1h writes), so its
-     * cost is authoritative and only the policy is applied on top. Everything
-     * else is priced from reported tokens. Tool cost is stripped either way —
-     * it is re-derived from `toolResults` below and must not be counted twice.
+     * Any provider that reports cache buckets also prices itself, because only
+     * it knows the tiers involved — Anthropic's 5m vs 1h writes cannot be
+     * reconstructed from a single `cacheWrite` count. Its cost is therefore
+     * authoritative and only the policy is applied on top. The fallback prices
+     * providers that report no cache usage at all.
+     *
+     * Tool cost is stripped either way: it is re-derived from `toolResults`
+     * below and must not be counted twice.
      */
     response.cost = response.cost
       ? (applyModelCostPolicy(withoutToolCost(response.cost), costPolicy) as typeof response.cost)
-      : calculateBillableModelCost(response.model, promptTokens, completionTokens, {
-          cacheRead,
-          ...(cacheWrite ? { cacheWrites: [{ tokens: cacheWrite, inputRateMultiplier: 1 }] } : {}),
-          isBYOK,
-        })
+      : calculateBillableModelCost(response.model, promptTokens, completionTokens, { isBYOK })
 
     if (!costPolicy.billable) {
       logger.info(

apps/sim/providers/openai/usage.ts

@@ -1,14 +1,9 @@
 import type { BlockTokens } from '@/executor/types'
-import {
-  LIST_PRICE_POLICY,
-  type ModelCostPolicy,
-  type ModelUsage,
-  priceModelUsage,
-} from '@/providers/cost-policy'
+import { LIST_PRICE_POLICY, type ModelUsage, priceModelUsage } from '@/providers/cost-policy'
 import {
   OPENAI_CACHE_WRITE_MULTIPLIER,
   type ResponsesUsageTokens,
-  toOpenAIModelUsage,
+  splitOpenAIUsage,
 } from '@/providers/openai/utils'
 import type { ModelPricing } from '@/providers/types'
 
@@ -34,10 +29,6 @@ interface OpenAIUsageCost {
   pricing: ModelPricing
 }
 
-function tokenCount(value: number | undefined): number {
-  return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, value) : 0
-}
-
 function roundedCost(value: number): number {
   return Number.parseFloat(value.toFixed(8))
 }
@@ -59,7 +50,7 @@ export function createOpenAIUsageAccumulator(): OpenAIUsageAccumulator {
  * Adds one Responses API turn's usage without counting cache tokens as
  * uncached input.
  *
- * Normalization goes through {@link toOpenAIModelUsage} so that subtracting the
+ * Normalization goes through {@link splitOpenAIUsage} so that subtracting the
  * cache buckets out of the prompt total — and clamping a vendor payload that
  * reports more cache tokens than it processed — stays in one place.
  */
@@ -69,15 +60,13 @@ export function addOpenAIUsage(
 ): void {
   if (!usage) return
 
-  const normalized = toOpenAIModelUsage(usage)
+  const split = splitOpenAIUsage(usage)
 
-  accumulator.input += tokenCount(normalized.input)
-  accumulator.output += tokenCount(normalized.output)
-  accumulator.cacheRead += tokenCount(normalized.cacheRead)
-  for (const write of normalized.cacheWrites ?? []) {
-    accumulator.cacheWrite += tokenCount(write.tokens)
-  }
-  accumulator.total += tokenCount(usage.totalTokens)
+  accumulator.input += split.input
+  accumulator.output += split.output
+  accumulator.cacheRead += split.cacheRead
+  accumulator.cacheWrite += split.cacheWrite
+  accumulator.total += usage.totalTokens
 }
 
 /**
@@ -117,14 +106,17 @@ export function buildOpenAIModelUsage(accumulator: OpenAIUsageAccumulator): Mode
 /**
  * Prices one OpenAI request, cache reads and writes included, through the
  * shared pricing function.
+ *
+ * Always at list price. Billability and the margin are applied once, centrally,
+ * by `executeProviderRequest` — a provider applying them here would double-count
+ * the multiplier.
  */
 export function buildOpenAIUsageCost(
   model: string,
   accumulator: OpenAIUsageAccumulator,
-  toolCost = 0,
-  policy: ModelCostPolicy = LIST_PRICE_POLICY
+  toolCost = 0
 ): OpenAIUsageCost {
-  const cost = priceModelUsage(model, buildOpenAIModelUsage(accumulator), policy)
+  const cost = priceModelUsage(model, buildOpenAIModelUsage(accumulator), LIST_PRICE_POLICY)
 
   return {
     input: cost.input,

apps/sim/providers/openai/utils.ts

@@ -21,27 +21,49 @@ export interface ResponsesUsageTokens {
 export const OPENAI_CACHE_WRITE_MULTIPLIER = 1.25
 
 /**
- * Normalizes OpenAI usage into the shared {@link ModelUsage} shape.
+ * One OpenAI response's tokens split into the buckets that price differently.
+ * `input` is the uncached remainder, so `input + cacheRead + cacheWrite` is the
+ * prompt total OpenAI reported.
+ */
+export interface OpenAITokenSplit {
+  input: number
+  output: number
+  cacheRead: number
+  cacheWrite: number
+}
+
+/**
+ * Splits a cache-inclusive OpenAI prompt total into its billing buckets.
  *
- * `cached_tokens` is a subset of `input_tokens`, so the uncached remainder is
- * the subtraction — the opposite of Anthropic, whose `input_tokens` already
- * excludes cache tokens.
+ * `cached_tokens` and `cache_write_tokens` are subsets of `input_tokens`, so the
+ * uncached remainder is the subtraction — the opposite of Anthropic, whose
+ * `input_tokens` already excludes cache tokens.
+ *
+ * Both buckets are clamped to what the request actually contained. OpenAI has
+ * shipped payloads where reads plus writes summed past the prompt total, so
+ * without this a vendor reporting bug becomes an overcharge.
  */
-export function toOpenAIModelUsage(usage: ResponsesUsageTokens): ModelUsage {
+export function splitOpenAIUsage(usage: ResponsesUsageTokens): OpenAITokenSplit {
   const promptTokens = Math.max(0, usage.promptTokens)
   const cacheRead = Math.min(Math.max(0, usage.cachedTokens), promptTokens)
-  /**
-   * A write can only cover tokens this request processed uncached, so it can
-   * never exceed the remainder. OpenAI has shipped usage payloads where reads
-   * plus writes summed past the prompt total; clamping keeps a vendor
-   * reporting bug from over-charging the run.
-   */
   const cacheWrite = Math.min(Math.max(0, usage.cacheWriteTokens), promptTokens - cacheRead)
 
   return {
     input: promptTokens - cacheRead - cacheWrite,
     output: usage.completionTokens,
     cacheRead,
+    cacheWrite,
+  }
+}
+
+/** Adapts a {@link splitOpenAIUsage} result to the shared pricing shape. */
+export function toOpenAIModelUsage(usage: ResponsesUsageTokens): ModelUsage {
+  const { input, output, cacheRead, cacheWrite } = splitOpenAIUsage(usage)
+
+  return {
+    input,
+    output,
+    cacheRead,
     cacheWrites: [{ tokens: cacheWrite, inputRateMultiplier: OPENAI_CACHE_WRITE_MULTIPLIER }],
   }
 }