fix(billing): count a resumed turn's journaled spend toward the usage limit once

- A turn an earlier process journaled adds its model spend to the run's unrecorded total the first
  time this run opens it; reopening the turn (fallback model, block retry) never counts it again
- Type the continued-call test's tool as a ProviderToolConfig

Author: waleedlatif1

apps/sim/executor/types.ts

@@ -680,6 +680,8 @@ export interface ExecutionContext {
 export interface UnrecordedModelCost {
   total: number
   readDeferredUntil?: number
+  /** Agent turns whose journaled spend `total` already holds. */
+  countedTurnIds?: Set<string>
 }
 
 /**

apps/sim/lib/memory/conversation-types.ts

@@ -91,6 +91,7 @@ export interface AgentConversationSession {
   getFinalResponse(): AgentTurnState['final']
   getFinalAssistantContent(): string | undefined
   readonly memoryId?: string
+  readonly turnId?: string
   getUsage(): ConversationUsageTotal
   recordContextUsage?(usage: ConversationUsageTotal): Promise<void>
   captureStep(step: CapturedConversationStep): Promise<void>

apps/sim/providers/index.ts

@@ -37,7 +37,7 @@ import {
 } from '@/providers/file-attachments.server'
 import { isEvaluationModel, isKnownModelId, supportsTemperature } from '@/providers/models'
 import { getProviderExecutor } from '@/providers/registry'
-import { addSettledCost } from '@/providers/run-usage-limit'
+import { addSettledCost, recordJournaledModelCost } from '@/providers/run-usage-limit'
 import {
   type ProviderRuntimeContext,
   runWithProviderRuntimeContext,
@@ -358,6 +358,7 @@ export async function executeProviderRequest(
       priorConversationUsage = session.getUsage()
       // A stop bills what success would: this journaled usage plus the request's own steps.
       addSettledCost(settledCost, priorConversationUsage.cost)
+      recordJournaledModelCost(requestRuntimeContext, session.turnId, priorConversationUsage)
       bindConversationGenerationCompactor(
         modelSafeRequest,
         createAgentConversationCompactor(

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

@@ -39,6 +39,7 @@ import { resetMidRunUsageCaches } from '@/lib/billing/core/mid-run-usage'
 import { NEAR_LIMIT_USAGE_GATE_TTL_MS } from '@/lib/billing/core/usage-gate-cache'
 import { markFailureKind } from '@/lib/core/errors/failure-log'
 import { isNonRetryableExecutionError } from '@/lib/execution/non-retryable-error'
+import { AgentTurnSession } from '@/lib/memory/agent-turn-session'
 import { AgentTurnStateMachine } from '@/lib/memory/turn-state'
 import type { ExecutionContext } from '@/executor/types'
 import { readTrustedExecutionCost } from '@/executor/utils/errors'
@@ -55,7 +56,7 @@ import {
 } from '@/providers/conversation-history'
 import { executeProviderTool } from '@/providers/runtime-context'
 import { providerFailureLogLevel } from '@/providers/streaming-tool-loop-shared'
-import { ProviderError, type ProviderRequest } from '@/providers/types'
+import { ProviderError, type ProviderRequest, type ProviderToolConfig } from '@/providers/types'
 
 const { mockCheckExecutionUsageLimits } = billingUsageGateCacheMockFns
 const { mockExecuteTool } = toolsMockFns
@@ -203,8 +204,54 @@ describe('run usage limit', () => {
     expect(readTrustedExecutionCost(failure)).toEqual({ input: 1, output: 1, total: 2 })
   })
 
+  it("counts a resumed turn's journaled spend toward the limit once, however often the run reopens it", async () => {
+    mockCheckExecutionUsageLimits.mockResolvedValue({
+      isExceeded: false,
+      payerUsage: { currentUsage: 1, limit: 5 },
+    })
+    const reopenTurn = () =>
+      new AgentTurnSession(
+        'turn-1',
+        { save: vi.fn() },
+        {
+          version: 1,
+          steps: [
+            {
+              id: 'earlier-process-step',
+              assistant: { role: 'assistant', content: 'Partial answer' },
+              calls: [],
+              results: [],
+              usage: { input: 1, output: 1 },
+              cost: { input: 1, output: 1, total: 2 },
+            },
+          ],
+        }
+      )
+    const run = startRun()
+    mockExecuteRequest.mockImplementation(async (request: ProviderRequest) => {
+      await prepareConversationGeneration(request, 'anthropic', { messages: request.messages })
+      throw new Error('Model call sent')
+    })
+    const request = { model: 'model-a', messages: [{ role: 'user' as const, content: 'Continue' }] }
+
+    const attempt = () =>
+      executeProviderRequest('anthropic', request, {
+        executionContext: run,
+        agentConversation: reopenTurn(),
+      })
+
+    await expect(attempt()).rejects.toThrow('Model call sent')
+    await expect(attempt()).rejects.toThrow('Model call sent')
+    expect(run.unrecordedModelCost?.total).toBe(2)
+  })
+
   it('bills a retried pending tool call once, through the journal that records it', async () => {
-    const tool = { id: 'search', name: 'search', description: 'search', params: {} }
+    const tool: ProviderToolConfig = {
+      id: 'search',
+      description: 'search',
+      params: {},
+      parameters: { type: 'object', properties: {}, required: [] },
+    }
     const session = new AgentTurnStateMachine(
       { save: vi.fn() },
       {

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

@@ -4,6 +4,7 @@ import { isPaid } from '@/lib/billing/plan-helpers'
 import { resolveUsageUpgradePayload } from '@/lib/billing/usage-upgrade'
 import { markFailureKind } from '@/lib/core/errors/failure-log'
 import { NonRetryableExecutionError } from '@/lib/execution/non-retryable-error'
+import type { ConversationUsageTotal } from '@/lib/memory/conversation-types'
 import { attachTrustedExecutionCost } from '@/executor/utils/errors'
 import type { ModelCost } from '@/providers/cost-policy'
 import type { TokenUsageCost } from '@/providers/pricing'
@@ -26,6 +27,25 @@ export function addSettledCost(settledCost: TokenUsageCost, cost: TokenUsageCost
   settledCost.total += cost.total
 }
 
+/**
+ * Adds a resumed Agent turn's journaled model spend to its run's unrecorded total, once per turn.
+ * Steps an earlier attempt journaled in another process were never counted by this run, while a
+ * turn this run already opened (a fallback model, a block retry) holds steps it counted as they
+ * settled. Journaled tool costs are left out, as settled ones are.
+ */
+export function recordJournaledModelCost(
+  runtime: ProviderRuntimeContext,
+  turnId: string | undefined,
+  usage: ConversationUsageTotal
+): void {
+  const unrecorded = runtime.executionContext?.unrecordedModelCost
+  if (!unrecorded || !turnId) return
+  unrecorded.countedTurnIds ??= new Set()
+  if (unrecorded.countedTurnIds.has(turnId)) return
+  unrecorded.countedTurnIds.add(turnId)
+  unrecorded.total += usage.cost.total - usage.cost.toolCost
+}
+
 /**
  * Adds a settled model step's billed cost to its request's and its run's running totals. Tool
  * costs reach only the request's: a workflow tool's child already spends against the run's.