Fixes

Author: Sg312

apps/sim/executor/execution/block-executor.test.ts

@@ -10,9 +10,10 @@ import { BlockType } from '@/executor/constants'
 import type { DAGNode } from '@/executor/dag/builder'
 import { BlockExecutor } from '@/executor/execution/block-executor'
 import { ExecutionState } from '@/executor/execution/state'
-import type { BlockHandler, ExecutionContext } from '@/executor/types'
+import type { BlockHandler, ExecutionContext, NormalizedBlockOutput } from '@/executor/types'
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 import { VariableResolver } from '@/executor/variables/resolver'
+import { installStreamingCostPolicy } from '@/providers/cost-policy'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 
 const { mockUploadFile } = vi.hoisted(() => ({
@@ -661,6 +662,9 @@ describe('BlockExecutor streaming pump', () => {
     attachThinkingOnDrain?: string
     failAfterText?: string
     onFullContent?: (content: string) => void | Promise<void>
+    outputOverrides?: Partial<NormalizedBlockOutput>
+    attachModelCostOnDrain?: { input: number; output: number; total: number }
+    nonBillableStreamingCost?: boolean
   }): BlockHandler {
     return {
       canHandle: () => true,
@@ -683,6 +687,13 @@ describe('BlockExecutor streaming pump', () => {
             timeSegments: [timeSegment],
           },
           cost: { input: 0, output: 0, total: 0 },
+          ...options.outputOverrides,
+        }
+        if (options.nonBillableStreamingCost) {
+          installStreamingCostPolicy(output as NormalizedBlockOutput, {
+            billable: false,
+            multiplier: 0,
+          })
         }
 
         const stream = new ReadableStream({
@@ -702,6 +713,9 @@ describe('BlockExecutor streaming pump', () => {
             if (options.attachThinkingOnDrain) {
               timeSegment.thinkingContent = options.attachThinkingOnDrain
             }
+            if (options.attachModelCostOnDrain) {
+              timeSegment.cost = options.attachModelCostOnDrain
+            }
             controller.close()
           },
         })
@@ -786,6 +800,53 @@ describe('BlockExecutor streaming pump', () => {
     expect(state.getBlockOutput(block.id)?.content).toBe('offline answer')
   })
 
+  it('preserves trusted custom-model billing metadata through streamed structured output', async () => {
+    const estimatedProviderCost = {
+      available: true,
+      input: 0.0003,
+      output: 0.0006,
+      total: 0.0009,
+      pricing: {
+        input: 0.3,
+        cachedInput: 0.059,
+        output: 1.2,
+        updatedAt: '2026-08-03',
+      },
+    }
+    const handler = createAgentEventsStreamingHandler({
+      events: [
+        {
+          type: 'text_delta',
+          text: JSON.stringify({
+            answer: 'ok',
+            estimatedProviderCost: { available: true, total: 999 },
+          }),
+          turn: 'final',
+        },
+      ],
+      outputOverrides: { estimatedProviderCost },
+      attachModelCostOnDrain: { input: 0.1, output: 0.2, total: 0.3 },
+      nonBillableStreamingCost: true,
+    })
+    const { executor, block, state } = createExecutor(handler)
+    ;(block.config.params as Record<string, unknown>).responseFormat = {
+      name: 'answer',
+      schema: { type: 'object', properties: { answer: { type: 'string' } } },
+    }
+
+    await executor.execute(createContext(state), createNode(block), block)
+
+    expect(state.getBlockOutput(block.id)).toMatchObject({
+      answer: 'ok',
+      tokens: { input: 1, output: 2, total: 3 },
+      cost: { input: 0, output: 0, total: 0 },
+      estimatedProviderCost,
+      providerTiming: {
+        timeSegments: [{ cost: { input: 0, output: 0, total: 0 } }],
+      },
+    })
+  })
+
   it('throws on mid-stream provider error (no truncated success)', async () => {
     const handler = createAgentEventsStreamingHandler({
       failAfterText: 'partial',

apps/sim/executor/execution/block-executor.ts

@@ -61,6 +61,7 @@ import {
   FUNCTION_BLOCK_DISPLAY_CODE_KEY,
   type VariableResolver,
 } from '@/executor/variables/resolver'
+import { finalizeStreamingCostPolicy } from '@/providers/cost-policy'
 import { createAgentStreamPump } from '@/providers/stream-pump'
 import type { SerializedBlock } from '@/serializer/types'
 import { SYSTEM_SUBBLOCK_IDS } from '@/triggers/constants'
@@ -916,6 +917,11 @@ export class BlockExecutor {
         await onStreamPromise.catch(() => {})
       }
       throw error instanceof Error ? error : new Error(String(error))
+    } finally {
+      // Provider segments receive their final usage/cost only while draining.
+      // Reapply the previously installed billing policy before logs or traces
+      // can observe those late-written values.
+      finalizeStreamingCostPolicy(streamingExec.execution?.output)
     }
 
     if (onStreamPromise) {
@@ -995,6 +1001,10 @@ export class BlockExecutor {
             toolCalls: executionOutput.toolCalls,
             providerTiming: executionOutput.providerTiming,
             cost: executionOutput.cost,
+            // Provider metadata is trusted execution state, not model output.
+            // Preserve it across structured-output reconstruction and overwrite
+            // any same-named field the model emitted in `parsed`.
+            estimatedProviderCost: executionOutput.estimatedProviderCost,
             model: executionOutput.model,
           }
           parsedForFormat = true

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.test.ts

@@ -497,6 +497,38 @@ describe('validateInputsForBlock', () => {
     expect(result.validInputs.model).toBe('gpt-5.4')
   })
 
+  it('accepts and canonicalizes a custom-model object from the VFS JSON schema', () => {
+    const result = validateInputsForBlock(
+      'agent',
+      {
+        customModelConfig: {
+          provider: 'fireworks',
+          model: 'accounts/fireworks/models/minimax-m2p7',
+          credentials: { mode: 'explicit', apiKey: '{{FIREWORKS_API_KEY}}' },
+        },
+      },
+      'agent-1'
+    )
+
+    expect(result.errors).toHaveLength(0)
+    expect(JSON.parse(result.validInputs.customModelConfig)).toMatchObject({
+      provider: 'fireworks',
+      model: 'fireworks/minimax-m2.7',
+      credentials: { mode: 'explicit', apiKey: '{{FIREWORKS_API_KEY}}' },
+    })
+  })
+
+  it('rejects an invalid custom-model object before execution', () => {
+    const result = validateInputsForBlock(
+      'agent',
+      { customModelConfig: { provider: 'unknown', model: 'future' } },
+      'agent-1'
+    )
+
+    expect(result.validInputs.customModelConfig).toBeUndefined()
+    expect(result.errors[0]?.error).toContain('Invalid custom model configuration')
+  })
+
   it('rejects a pattern-matching but uncataloged id even with surrounding whitespace', () => {
     const result = validateInputsForBlock('agent', { model: '  gpt-100-ultra  ' }, 'agent-1')
 

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts

@@ -17,7 +17,7 @@ import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { getAgentModelOptions, getModelOptions } from '@/blocks/utils'
 import { BlockType, EDGE, normalizeName } from '@/executor/constants'
-import { isCustomModel } from '@/providers/custom-model'
+import { isCustomModel, parseCustomModelConfig } from '@/providers/custom-model'
 import {
   isAutoModel,
   isCustomJsonOnlyModel,
@@ -527,6 +527,27 @@ export function validateValueForSubBlockType(
     }
 
     case 'code': {
+      if (fieldName === 'customModelConfig') {
+        try {
+          // VFS advertises this field as JSON, while the editor's code
+          // subblock persists text. Accept the object Mothership naturally
+          // produces, validate it now, and store one canonical JSON string.
+          const parsed = parseCustomModelConfig(value)
+          return { valid: true, value: JSON.stringify(parsed, null, 2) }
+        } catch (error) {
+          return {
+            valid: false,
+            error: {
+              blockId,
+              blockType,
+              field: fieldName,
+              value,
+              error: `Invalid custom model configuration: ${toError(error).message}`,
+            },
+          }
+        }
+      }
+
       // Code must be a string (content can be JS, Python, JSON, SQL, HTML, etc.)
       if (typeof value !== 'string') {
         return {

apps/sim/lib/copilot/vfs/serializers.ts

@@ -1060,7 +1060,7 @@ export function serializeTriggerSchema(trigger: {
       description: trigger.description,
       version: trigger.version,
       webhook: trigger.webhook || undefined,
-      subBlocks: trigger.subBlocks.map(serializeSubBlock),
+      subBlocks: trigger.subBlocks.map((subBlock) => serializeSubBlock(subBlock, false)),
       outputs: trigger.outputs,
     },
     null,
@@ -1080,7 +1080,7 @@ export function serializeBuiltinTriggerSchema(block: BlockConfig): string {
       longDescription: block.longDescription || undefined,
       category: 'builtin',
       triggers: block.triggers || undefined,
-      subBlocks: block.subBlocks.map(serializeSubBlock),
+      subBlocks: block.subBlocks.map((subBlock) => serializeSubBlock(subBlock, false)),
       inputs: block.inputs,
       outputs: block.outputs,
     },

apps/sim/lib/workflows/blocks/block-outputs.test.ts

@@ -51,6 +51,7 @@ describe('block outputs parity', () => {
             properties: {
               min: { type: 'number' },
               max: { type: 'number' },
+              cost: { type: 'string' },
             },
             required: ['min', 'max'],
             additionalProperties: false,
@@ -67,8 +68,19 @@ describe('block outputs parity', () => {
     expect(rootPaths(paths)).toEqual(Object.keys(outputs).sort())
     expect(paths).toContain('min')
     expect(paths).toContain('max')
+    expect(paths).toEqual(
+      expect.arrayContaining([
+        'model',
+        'tokens',
+        'toolCalls',
+        'providerTiming',
+        'cost',
+        'estimatedProviderCost',
+      ])
+    )
     expect(getEffectiveBlockOutputType('agent', 'min', subBlocks, options)).toBe('number')
     expect(getEffectiveBlockOutputType('agent', 'max', subBlocks, options)).toBe('number')
+    expect(getEffectiveBlockOutputType('agent', 'cost', subBlocks, options)).toBe('json')
   })
 
   it.concurrent('surfaces start run metadata paths only when the toggle is on', () => {

apps/sim/lib/workflows/blocks/block-outputs.ts

@@ -41,6 +41,15 @@ interface EffectiveOutputOptions {
 
 type ConditionValue = string | number | boolean
 
+const AGENT_STRUCTURED_METADATA_OUTPUTS = new Set([
+  'model',
+  'tokens',
+  'toolCalls',
+  'providerTiming',
+  'cost',
+  'estimatedProviderCost',
+])
+
 /**
  * Checks if a value is a valid primitive for condition comparison.
  */
@@ -410,7 +419,16 @@ export function getEffectiveBlockOutputs(
 
   if (blockType === 'agent') {
     const responseFormatOutputs = getResponseFormatOutputs(subBlocks, 'agent')
-    if (responseFormatOutputs) return responseFormatOutputs
+    if (responseFormatOutputs) {
+      const agentOutputs = getBlockOutputs('agent', subBlocks, false, { includeHidden })
+      const trustedMetadata = Object.fromEntries(
+        Object.entries(agentOutputs).filter(([key]) => AGENT_STRUCTURED_METADATA_OUTPUTS.has(key))
+      )
+      // Runtime structured output is rebuilt the same way: model fields first,
+      // then trusted provider metadata. Keep discovery aligned and prevent a
+      // response schema from redefining billing/token fields.
+      return { ...responseFormatOutputs, ...trustedMetadata }
+    }
   }
 
   let baseOutputs: OutputDefinition

apps/sim/lib/workflows/credentials/credential-extractor.ts

@@ -231,7 +231,10 @@ interface SanitizedWorkflowState {
  * workflow leaves its workspace, preserving only an unresolved env reference
  * for explicit exports when requested.
  */
-function sanitizeCustomModelCredential(value: unknown, preserveEnvVars: boolean): unknown {
+function sanitizeCustomModelCredential(
+  value: unknown,
+  preserveEnvVars: boolean
+): SubBlockState['value'] {
   const wasString = typeof value === 'string'
   let parsed: unknown = value
   if (wasString) {
@@ -246,7 +249,7 @@ function sanitizeCustomModelCredential(value: unknown, preserveEnvVars: boolean)
   const config = structuredClone(parsed) as Record<string, unknown>
   const credentials = config.credentials
   if (!credentials || typeof credentials !== 'object' || Array.isArray(credentials)) {
-    return value
+    return wasString ? value : JSON.stringify(config, null, 2)
   }
 
   const sanitizedCredentials = credentials as Record<string, unknown>
@@ -255,7 +258,7 @@ function sanitizeCustomModelCredential(value: unknown, preserveEnvVars: boolean)
     preserveEnvVars && typeof apiKey === 'string' && /^\{\{[^{}]+\}\}$/.test(apiKey.trim())
   if (!preserveReference) sanitizedCredentials.apiKey = undefined
 
-  return wasString ? JSON.stringify(config, null, 2) : config
+  return JSON.stringify(config, null, 2)
 }
 
 /**

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

@@ -9,6 +9,7 @@ import {
   applySegmentCostPolicy,
   buildEstimatedProviderCost,
   calculateBillableModelCost,
+  finalizeStreamingCostPolicy,
   installStreamingCostPolicy,
   LIST_PRICE_POLICY,
   priceModelUsage,
@@ -295,6 +296,34 @@ describe('installStreamingCostPolicy', () => {
       total: 0.0015,
     })
   })
+
+  it('scrubs model-segment cost written after streaming interception', () => {
+    const output = {
+      cost: { input: 0, output: 0, total: 0 },
+      providerTiming: {
+        startTime: new Date(0).toISOString(),
+        endTime: new Date(1).toISOString(),
+        duration: 1,
+        timeSegments: [],
+      },
+    } as NormalizedBlockOutput
+    installStreamingCostPolicy(output, { billable: false, multiplier: 0 })
+
+    output.providerTiming?.timeSegments?.push({
+      type: 'model',
+      startTime: 0,
+      endTime: 1,
+      duration: 1,
+      cost: { input: 0.1, output: 0.2, total: 0.3 },
+    })
+    finalizeStreamingCostPolicy(output)
+
+    expect(output.providerTiming?.timeSegments?.[0].cost).toEqual({
+      input: 0,
+      output: 0,
+      total: 0,
+    })
+  })
 })
 
 describe('applySegmentCostPolicy', () => {