fix(billing): bill journaled attempts on the usage stop

Author: waleedlatif1

apps/sim/providers/index.ts

@@ -294,6 +294,8 @@ export async function executeProviderRequest(
   const modelSafeRequest = await prepareProviderFileAttachments(sanitizedRequest)
   const toolIdentities = assignProviderToolIdentities(modelSafeRequest.tools)
   const failedFunctionToolCost = { total: 0 }
+  // A conversation summary charges its parent request, so a stop after compaction bills it.
+  const settledCost = runtimeContext?.settledCost ?? { input: 0, output: 0, total: 0 }
   const requestRuntimeContext: ProviderRuntimeContext = {
     ...runtimeContext,
     ...(runtimeContext?.agentConversation
@@ -305,8 +307,7 @@ export async function executeProviderRequest(
         }
       : {}),
     failedFunctionToolCost,
-    // A conversation summary charges its parent request, so a stop after compaction bills it.
-    settledCost: runtimeContext?.settledCost ?? { input: 0, output: 0, total: 0 },
+    settledCost,
     ...(toolIdentities.toolIdByWireId.size > 0
       ? {
           toolIdByWireId: new Map([
@@ -351,6 +352,10 @@ export async function executeProviderRequest(
         .find((message) => message.role === 'user' && !isConversationHistoryNotice(message))
       bindConversationGenerationPrompt(modelSafeRequest, currentUserMessage)
       priorConversationUsage = session.getUsage()
+      // A stop bills what success would: this journaled usage plus the request's own steps.
+      settledCost.input += priorConversationUsage.cost.input
+      settledCost.output += priorConversationUsage.cost.output
+      settledCost.total += priorConversationUsage.cost.total
       bindConversationGenerationCompactor(
         modelSafeRequest,
         createAgentConversationCompactor(

apps/sim/providers/run-usage-limit.test.ts

@@ -38,6 +38,7 @@ import type { BillingAttributionSnapshot } from '@/lib/billing/core/attribution'
 import { resetMidRunUsageCaches } from '@/lib/billing/core/mid-run-usage'
 import { NEAR_LIMIT_USAGE_GATE_TTL_MS } from '@/lib/billing/core/usage-gate-cache'
 import { isNonRetryableExecutionError } from '@/lib/execution/non-retryable-error'
+import { AgentTurnStateMachine } from '@/lib/memory/turn-state'
 import type { ExecutionContext } from '@/executor/types'
 import { readTrustedExecutionCost } from '@/executor/utils/errors'
 import { executeProviderRequest } from '@/providers'
@@ -160,6 +161,40 @@ describe('run usage limit', () => {
     expect(parentCost).toEqual({ input: 0.5, output: 0.25, total: 0.75 })
   })
 
+  it('bills a stopped attempt for the journaled steps a successful one would have billed', async () => {
+    const session = new AgentTurnStateMachine(
+      { save: vi.fn() },
+      {
+        version: 1,
+        steps: [
+          {
+            id: 'failed-attempt-step',
+            assistant: { role: 'assistant', content: 'Partial answer' },
+            calls: [],
+            results: [],
+            usage: { input: 1, output: 1 },
+            cost: { input: 1, output: 1, total: 2 },
+          },
+        ],
+      }
+    )
+    const run = startRun()
+    run.unrecordedModelCost = { total: 2 }
+    mockExecuteRequest.mockImplementation(async (request: ProviderRequest) => {
+      await prepareConversationGeneration(request, 'anthropic', { messages: [] })
+      return { content: '', model: request.model }
+    })
+
+    const failure = await executeProviderRequest(
+      'anthropic',
+      { model: 'model-a', messages: [{ role: 'user', content: 'Continue' }] },
+      { executionContext: run, agentConversation: session }
+    ).catch((caught: unknown) => caught)
+
+    expect(isNonRetryableExecutionError(failure)).toBe(true)
+    expect(readTrustedExecutionCost(failure)).toEqual({ input: 1, output: 1, total: 2 })
+  })
+
   it('counts every block of the run, not only the request that is running', async () => {
     const run = startRun()
     await modelStep(startRequest(run), 1, 1)