fix lint

Author: Sg312

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

@@ -21,6 +21,7 @@ import { AGENT, BlockType, isMcpTool } from '@/executor/constants'
 import { AgentBlockHandler } from '@/executor/handlers/agent/agent-handler'
 import type { ExecutionContext, StreamingExecution } from '@/executor/types'
 import { executeProviderRequest } from '@/providers'
+import { installStreamingCostPolicy } from '@/providers/cost-policy'
 import { SIM_AUTO_MODEL_ID } from '@/providers/models'
 import { getProviderFromModel, transformBlockTool } from '@/providers/utils'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
@@ -348,6 +349,45 @@ describe('AgentBlockHandler', () => {
       expect(buildAutoRoutingSignalsFor({ files: [{ id: 'f3' }] }).mediaKind).toBe('file')
     })
 
+    it('overlays the routing charge on a streaming cost written after the fact', async () => {
+      // Mirrors the real streaming shape: the policy accessor is installed at
+      // provider-return time, the drain writes the final cost long after the
+      // handler returned, and consumers read it at log time.
+      const output: Record<string, unknown> = { cost: { input: 0, output: 0, total: 0 } }
+      installStreamingCostPolicy(output as never, { billable: true, multiplier: 1 })
+      const streaming = { stream: new ReadableStream(), execution: { output } }
+
+      ;(
+        handler as unknown as { applyRoutingCost: (r: unknown, c: number) => void }
+      ).applyRoutingCost(streaming, 0.002)
+
+      // The drain settles the model cost afterwards.
+
+      ;(output as { cost: unknown }).cost = { input: 0.01, output: 0.02, total: 0.03 }
+
+      expect(output.cost).toEqual({
+        input: 0.01,
+        output: 0.02,
+        total: expect.closeTo(0.032, 10),
+        routing: 0.002,
+      })
+    })
+
+    it('adds the routing charge to a settled non-streaming cost', async () => {
+      const result: Record<string, unknown> = { cost: { input: 0.01, output: 0.02, total: 0.03 } }
+
+      ;(
+        handler as unknown as { applyRoutingCost: (r: unknown, c: number) => void }
+      ).applyRoutingCost(result, 0.002)
+
+      expect(result.cost).toEqual({
+        input: 0.01,
+        output: 0.02,
+        total: expect.closeTo(0.032, 10),
+        routing: 0.002,
+      })
+    })
+
     it('leaves the reported model alone for an explicitly selected model', async () => {
       const result = (await handler.execute(mockContext, mockBlock, {
         model: 'gpt-4o',

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

@@ -163,12 +163,8 @@ export class AgentBlockHandler implements BlockHandler {
 
     const result = await this.executeProviderRequest(ctx, providerRequest, block, responseFormat)
 
-    // Routing cost lands on non-streaming outputs only for now; streaming
-    // outputs assemble cost at stream end where there is no hook yet. The
-    // charge is gated server-side by mothership's bill-model-router flag
-    // (default off), so this asymmetry currently bills nobody.
-    if (autoRouting && autoRouting.billableRoutingCost > 0 && !this.isStreamingExecution(result)) {
-      this.applyRoutingCost(result as BlockOutput, autoRouting.billableRoutingCost)
+    if (autoRouting && autoRouting.billableRoutingCost > 0) {
+      this.applyRoutingCost(result, autoRouting.billableRoutingCost)
     }
 
     if (autoRouting) {
@@ -289,17 +285,44 @@ export class AgentBlockHandler implements BlockHandler {
   }
 
   /**
-   * Adds the billable sim-auto routing charge to a non-streaming output's
-   * cost breakdown as a distinct `routing` component.
+   * Adds the billable sim-auto routing charge to the output's cost breakdown
+   * as a distinct `routing` component.
+   *
+   * A non-streaming cost is final, so it is mutated in place. A streaming
+   * output's cost settles at stream end — written through the accessor
+   * `installStreamingCostPolicy` installed — so the charge is layered as a
+   * read-time overlay on the property instead: whatever the drain writes,
+   * every later read (trace spans, cost summary, usage ledger) sees the
+   * routing component on top.
    */
-  private applyRoutingCost(output: BlockOutput, routingCost: number): void {
+  private applyRoutingCost(result: BlockOutput | StreamingExecution, routingCost: number): void {
+    const output = this.isStreamingExecution(result)
+      ? (result as StreamingExecution).execution?.output
+      : (result as BlockOutput)
+    if (!output || typeof output !== 'object') return
     const target = output as { cost?: Record<string, number> }
-    if (target.cost && typeof target.cost.total === 'number') {
-      target.cost.routing = routingCost
-      target.cost.total += routingCost
-    } else {
-      target.cost = { input: 0, output: 0, routing: routingCost, total: routingCost }
+
+    const withRouting = (cost: Record<string, number> | undefined): Record<string, number> =>
+      cost && typeof cost.total === 'number'
+        ? { ...cost, routing: routingCost, total: cost.total + routingCost }
+        : { input: 0, output: 0, routing: routingCost, total: routingCost }
+
+    if (!this.isStreamingExecution(result)) {
+      target.cost = withRouting(target.cost)
+      return
     }
+
+    const prior = Object.getOwnPropertyDescriptor(target, 'cost')
+    let raw = prior?.get ? undefined : (target.cost as Record<string, number> | undefined)
+    Object.defineProperty(target, 'cost', {
+      get: () => withRouting(prior?.get ? (prior.get.call(target) as never) : raw),
+      set: (value: Record<string, number> | undefined) => {
+        if (prior?.set) prior.set.call(target, value)
+        else raw = value
+      },
+      configurable: true,
+      enumerable: true,
+    })
   }
 
   private async validateToolPermissions(ctx: ExecutionContext, tools: ToolInput[]): Promise<void> {

apps/sim/lib/model-router/resolve.test.ts

@@ -51,9 +51,10 @@ const ctx = {
 } as unknown as ExecutionContext
 
 /** Distinct-by-default signals so the module-level decision cache never collides across tests. */
+let signalSeq = 0
 function makeSignals(overrides: Partial<AutoRoutingSignals> = {}): AutoRoutingSignals {
   return {
-    systemPrompt: `analyze the quarterly report ${Math.random()}`,
+    systemPrompt: `analyze the quarterly report ${++signalSeq}`,
     lastMessage: 'here is the data to reconcile against the ledger',
     messageCount: 1,
     toolNames: ['exa_search'],