goddammit

Author: Sg312

apps/sim/executor/handlers/agent/agent-handler.test.ts

@@ -362,6 +362,38 @@ describe('AgentBlockHandler', () => {
       })
     })
 
+    it('keeps the Fireworks deployment separate from the catalog billing model', async () => {
+      mockContext.userId = 'super-user'
+      mockExecuteProviderRequest.mockResolvedValue({
+        content: 'On-demand response',
+        model: 'fireworks/qwen3.7-max',
+        tokens: { input: 100, output: 20, total: 120 },
+      })
+
+      await handler.execute(mockContext, mockBlock, {
+        model: CUSTOM_MODEL_ID,
+        customModelConfig: {
+          provider: 'fireworks',
+          model: 'fireworks/qwen3.7-max',
+          deployment: 'accounts/acme/deployments/qwen-prod',
+          credentials: { mode: 'explicit', apiKey: 'fw-secret' },
+        },
+        userPrompt: 'Hello',
+      })
+
+      expect(mockExecuteProviderRequest).toHaveBeenCalledWith(
+        'fireworks',
+        expect.objectContaining({
+          model: 'fireworks/qwen3.7-max',
+          providerModel: 'accounts/acme/deployments/qwen-prod',
+          apiKey: 'fw-secret',
+          credentialMode: 'explicit',
+          capabilityPolicy: 'passthrough',
+        }),
+        expect.anything()
+      )
+    })
+
     it('rejects custom model execution when Super User mode is off', async () => {
       mockContext.userId = 'admin-with-toggle-off'
       mockVerifyEffectiveSuperUser.mockResolvedValue({

apps/sim/executor/types.ts

@@ -172,6 +172,21 @@ interface BlockCost {
       cachedInput?: number
       output: number
     }
+    serviceTiers?: {
+      priority?:
+        | { multiplier: number }
+        | {
+            input: number
+            cachedInput?: number
+            output: number
+            longContext?: {
+              threshold: number
+              input: number
+              cachedInput?: number
+              output: number
+            }
+          }
+    }
   }
 }
 

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

@@ -253,6 +253,14 @@ describe('withoutToolCost', () => {
     const cost = { input: 1, output: 2, total: 3 }
     expect(withoutToolCost(cost)).toBe(cost)
   })
+
+  it('preserves an exact vendor model total that differs from the displayed split', () => {
+    expect(withoutToolCost({ input: 0.3, output: 0.6, total: 1.05, toolCost: 0.05 })).toEqual({
+      input: 0.3,
+      output: 0.6,
+      total: 1,
+    })
+  })
 })
 
 describe('calculateBillableModelCost', () => {

apps/sim/providers/cost-policy.ts

@@ -31,7 +31,7 @@ export interface ModelCost {
 /** Cost that always carries pricing, as `ProviderResponse['cost']` requires. */
 export type PricedModelCost = ModelCost & { pricing: ModelPricing }
 
-/** Vendor list-price information shown for explicit custom credentials only. */
+/** Vendor list-price information shown for Custom JSON calls resolved to user credentials. */
 export interface EstimatedProviderCost {
   available: boolean
   input?: number
@@ -294,8 +294,8 @@ export function calculateBillableModelCost(
 export function withoutToolCost(cost: ModelCost): ModelCost {
   if (cost.toolCost === undefined) return cost
 
-  const { toolCost: _toolCost, ...model } = cost
-  return { ...model, total: roundCost(model.input + model.output) }
+  const { toolCost, ...model } = cost
+  return { ...model, total: roundCost(Math.max(0, model.total - toolCost)) }
 }
 
 /** Rejects NaN, Infinity, and negatives — a negative would credit the run. */

apps/sim/providers/fireworks/index.test.ts

@@ -145,6 +145,25 @@ describe('fireworksProvider', () => {
     })
   })
 
+  it('reports cached prompts separately from uncached input', async () => {
+    mockCreate.mockResolvedValueOnce({
+      ...textResponse('cached'),
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 5,
+        total_tokens: 15,
+        prompt_tokens_details: { cached_tokens: 4 },
+      },
+    })
+
+    const result = await fireworksProvider.executeRequest(baseRequest)
+
+    expect(result).toMatchObject({
+      tokens: { input: 6, cacheRead: 4, output: 5, total: 15 },
+      cost: expect.objectContaining({ input: expect.any(Number), output: expect.any(Number) }),
+    })
+  })
+
   it('sends the resolved wire model name while reporting the catalog id', async () => {
     mockCreate.mockResolvedValueOnce(textResponse('ok'))
     mockResolveFireworksWireModel.mockReturnValueOnce('accounts/fireworks/models/glm-5p2')

apps/sim/providers/trace-enrichment.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import { enrichLastModelSegmentFromChatCompletions } from '@/providers/trace-enrichment'
+
+describe('chat-completions trace enrichment', () => {
+  it('separates cached input and accepts provider-normalized token overrides', () => {
+    const segments: any[] = [
+      { type: 'model', name: 'model', startTime: 1, endTime: 2, duration: 1 },
+    ]
+    const response = {
+      choices: [{ message: { content: 'ok' }, finish_reason: 'stop' }],
+      usage: {
+        prompt_tokens: 100,
+        completion_tokens: 20,
+        total_tokens: 120,
+        prompt_tokens_details: { cached_tokens: 40 },
+        completion_tokens_details: { reasoning_tokens: 5 },
+      },
+    }
+
+    enrichLastModelSegmentFromChatCompletions(segments, response, undefined, {
+      cost: { input: 1, output: 2, total: 3 },
+    })
+    expect(segments[0].tokens).toEqual({
+      input: 60,
+      cacheRead: 40,
+      output: 20,
+      reasoning: 5,
+      total: 120,
+    })
+
+    enrichLastModelSegmentFromChatCompletions(segments, response, undefined, {
+      tokens: { input: 60, cacheRead: 40, output: 25, reasoning: 5, total: 125 },
+      cost: { input: 1, output: 2, total: 3 },
+    })
+    expect(segments[0].tokens).toEqual({
+      input: 60,
+      cacheRead: 40,
+      output: 25,
+      reasoning: 5,
+      total: 125,
+    })
+  })
+})

apps/sim/providers/trace-enrichment.ts

@@ -187,6 +187,8 @@ export function enrichLastModelSegmentFromChatCompletions(
     errorMessage?: string
     /** Override the automatically derived cost. */
     cost?: { input?: number; output?: number; total?: number }
+    /** Override normalized token buckets when provider semantics differ from OpenAI. */
+    tokens?: BlockTokens
   }
 ): void {
   const choice = response.choices[0]
@@ -228,15 +230,17 @@ export function enrichLastModelSegmentFromChatCompletions(
     thinkingContent: thinkingText,
     toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
     finishReason: choice?.finish_reason ?? undefined,
-    tokens: usage
-      ? {
-          input: promptTokens,
-          output: completionTokens,
-          total: usage.total_tokens ?? undefined,
-          ...(cacheRead > 0 && { cacheRead }),
-          ...(reasoning > 0 && { reasoning }),
-        }
-      : undefined,
+    tokens:
+      extras?.tokens ??
+      (usage
+        ? {
+            input: promptTokens === undefined ? undefined : Math.max(0, promptTokens - cacheRead),
+            output: completionTokens,
+            total: usage.total_tokens ?? undefined,
+            ...(cacheRead > 0 && { cacheRead }),
+            ...(reasoning > 0 && { reasoning }),
+          }
+        : undefined),
     cost: derivedCost,
     ttft: extras?.ttft,
     provider: extras?.provider,

apps/sim/providers/types.ts

@@ -150,9 +150,9 @@ export interface ProviderResponse {
     pricing: ModelPricing
   }
   /**
-   * Vendor list-price estimate for explicit custom credentials. This is
-   * informational only and never enters Sim's usage ledger; `cost` remains the
-   * authoritative amount Sim charges.
+   * Vendor list-price estimate for Custom JSON calls resolved to explicit or
+   * workspace BYOK credentials. This is informational only and never enters
+   * Sim's usage ledger; `cost` remains the authoritative amount Sim charges.
    */
   estimatedProviderCost?: {
     available: boolean

apps/sim/providers/utils.ts

@@ -940,7 +940,9 @@ export function calculateCost(
 
   const inputCost =
     promptTokens *
-    (useCachedInput && cachedInputRate ? cachedInputRate / 1_000_000 : inputRate / 1_000_000)
+    (useCachedInput && cachedInputRate !== undefined
+      ? cachedInputRate / 1_000_000
+      : inputRate / 1_000_000)
 
   const outputCost = completionTokens * (outputRate / 1_000_000)
   const finalInputCost = inputCost * (inputMultiplier ?? 1)