fix(custom-blocks): address review findings on agent-tool execution

Author: TheodoreSpeaks

apps/sim/executor/handlers/pi/sim-tools.ts

@@ -16,6 +16,7 @@ import type { PiToolResult, PiToolSpec } from '@/executor/handlers/pi/backend'
 import type { ExecutionContext } from '@/executor/types'
 import { transformBlockTool } from '@/providers/utils'
 import { executeTool } from '@/tools'
+import { mergeToolParameters } from '@/tools/params'
 import type { ToolResponse } from '@/tools/types'
 import { getTool } from '@/tools/utils'
 import { getToolAsync } from '@/tools/utils.server'
@@ -74,8 +75,11 @@ export async function buildSimToolSpecs(
             const result = await executeTool(
               toolId,
               {
-                ...preseededParams,
-                ...args,
+                // Same merge the Agent block's tool calls use: user-preseeded values
+                // win over LLM args, and `inputMapping` is deep-merged rather than
+                // replaced — a partial mapping from the model must not drop the
+                // user-filled fields baked onto the block.
+                ...mergeToolParameters(preseededParams, args as Record<string, unknown>),
                 // Trusted execution context, spread last so an LLM-supplied
                 // `_context` arg can't override it. executeTool reads this directly
                 // for OAuth-credential resolution and internal-route identity, the

apps/sim/executor/handlers/workflow/custom-block-tool-runner.test.ts

@@ -9,8 +9,11 @@ vi.mock('@/executor/handlers/workflow/workflow-handler', () => ({
   WorkflowBlockHandler: class {
     execute = mockExecute
   },
+  aggregateChildCost: (spans: Array<{ cost?: { total?: number } }>) =>
+    spans.reduce((sum, span) => sum + (span?.cost?.total ?? 0), 0),
 }))
 
+import { ChildWorkflowError } from '@/executor/errors/child-workflow-error'
 import {
   buildCustomBlockExecutionContext,
   runCustomBlockTool,
@@ -85,6 +88,20 @@ describe('runCustomBlockTool', () => {
     expect(res.error).toContain('not deployed')
   })
 
+  it('rolls up already-incurred child cost when the run fails', async () => {
+    const err: any = new Error('child blew up')
+    err.name = 'ChildWorkflowError'
+    err.childTraceSpans = [{ id: 's1', name: 'child', type: 'agent', cost: { total: 0.25 } }]
+    Object.setPrototypeOf(err, ChildWorkflowError.prototype)
+    mockExecute.mockRejectedValue(err)
+
+    const res = await runCustomBlockTool({ blockType: 'custom_block_abc', _context: {} })
+
+    expect(res.success).toBe(false)
+    // Partial spend must not be recorded as zero-cost.
+    expect((res.output as any).cost.total).toBeGreaterThan(0)
+  })
+
   it('rejects a missing block type without invoking the handler', async () => {
     const res = await runCustomBlockTool({ _context: {} })
     expect(res.success).toBe(false)

apps/sim/executor/handlers/workflow/custom-block-tool-runner.ts

@@ -2,7 +2,11 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
 import type { BillingAttributionSnapshot } from '@/lib/billing/core/billing-attribution'
-import { WorkflowBlockHandler } from '@/executor/handlers/workflow/workflow-handler'
+import { ChildWorkflowError } from '@/executor/errors/child-workflow-error'
+import {
+  aggregateChildCost,
+  WorkflowBlockHandler,
+} from '@/executor/handlers/workflow/workflow-handler'
 import type { ExecutionContext } from '@/executor/types'
 import type { SerializedBlock } from '@/serializer/types'
 import type { ToolResponse } from '@/tools/types'
@@ -109,11 +113,20 @@ export async function runCustomBlockTool(params: CustomBlockToolParams): Promise
       output && typeof output === 'object' && !Array.isArray(output) ? output : { result: output }
     return { success: true, output: normalized }
   } catch (error) {
-    // The handler throws a consumer-safe `ChildWorkflowError` on failure. Partial
-    // child cost rides its trace spans, but the provider tool loop only bills cost
-    // from successful results, so the error message alone is surfaced here.
+    // The handler throws a consumer-safe `ChildWorkflowError` on failure. Its trace
+    // spans are the only carrier of spend the child already incurred before failing,
+    // so roll that up onto the failed result too — otherwise a partially-run child is
+    // recorded as zero-cost.
     const message = getErrorMessage(error, 'Custom block execution failed')
+    const failedChildSpans = ChildWorkflowError.isChildWorkflowError(error)
+      ? error.childTraceSpans
+      : []
+    const childCost = aggregateChildCost(failedChildSpans)
     logger.info('Custom block tool execution failed', { blockType: params.blockType, message })
-    return { success: false, output: {}, error: message }
+    return {
+      success: false,
+      output: childCost > 0 ? { cost: { total: childCost } } : {},
+      error: message,
+    }
   }
 }

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

@@ -136,7 +136,7 @@ export function remapCustomBlockInputKeys(
  * breakdowns), minus the base execution charge the parent applies once itself.
  * A naive top-level `cost.total` sum undercounts when spend sits on nested children.
  */
-function aggregateChildCost(childTraceSpans: TraceSpan[]): number {
+export function aggregateChildCost(childTraceSpans: TraceSpan[]): number {
   if (childTraceSpans.length === 0) return 0
   const summary = calculateCostSummary(childTraceSpans)
   return Math.max(0, summary.totalCost - summary.baseExecutionCharge)

apps/sim/providers/custom-block-tool.test.ts

@@ -59,6 +59,34 @@ describe('transformBlockTool — custom blocks', () => {
     expect(mockResolve).toHaveBeenCalledWith('custom_block_test')
   })
 
+  it('does not offer the tool when a required file input has no preset value', async () => {
+    mockResolve.mockResolvedValue({
+      workflowId: 'wf-src',
+      inputFields: [{ id: 'f', name: 'Files', type: 'file[]' }],
+      requiredInputIds: ['f'],
+    })
+
+    const tool = await transformBlockTool({ type: 'custom_block_test', params: {} }, options)
+    expect(tool).toBeNull()
+  })
+
+  it('still offers the tool when a required file input is pre-filled on the block', async () => {
+    mockResolve.mockResolvedValue({
+      workflowId: 'wf-src',
+      inputFields: [{ id: 'f', name: 'Files', type: 'file[]' }],
+      requiredInputIds: ['f'],
+    })
+
+    const tool = await transformBlockTool(
+      { type: 'custom_block_test', params: { f: [{ id: 'file-1' }] } },
+      options
+    )
+    expect(tool).not.toBeNull()
+    // The preset value rides the baked mapping; the schema still omits the file field.
+    expect(tool!.params.inputMapping).toContain('file-1')
+    expect(Object.keys(tool!.parameters.properties.inputMapping.properties)).toEqual([])
+  })
+
   it('returns null (tool not offered) when the binding cannot be resolved', async () => {
     mockResolve.mockResolvedValue(null)
     const tool = await transformBlockTool({ type: 'custom_block_test', params: {} }, options)

apps/sim/providers/utils.ts

@@ -634,6 +634,23 @@ export async function transformBlockTool(
       logger.warn('custom_block_executor tool not registered')
       return null
     }
+    const inputMapping = assembleCustomBlockInputMapping(block.params || {})
+    // A `file[]` field is omitted from the model schema (the model can't synthesize
+    // upload descriptors). If such a field is REQUIRED and the user hasn't
+    // pre-filled it on the block, no invocation could ever satisfy the child's
+    // required-input check — so don't offer an unusable tool at all.
+    const prefilled = JSON.parse(inputMapping) as Record<string, unknown>
+    const requiredIds = new Set(binding.requiredInputIds)
+    const unfillableFileField = binding.inputFields.find((field) => {
+      const key = field.id ?? field.name
+      return isFileFieldType(field.type) && requiredIds.has(key) && !(key in prefilled)
+    })
+    if (unfillableFileField) {
+      logger.warn(
+        `Custom block ${block.type} not offered as a tool: required file input "${unfillableFileField.name}" has no preset value and cannot be supplied by the model`
+      )
+      return null
+    }
     return {
       // Unique per block so two custom-block tools never collide on the wire.
       id: `custom_block_executor_${block.type}`,
@@ -643,7 +660,7 @@ export async function transformBlockTool(
       description: blockDef.description || customToolConfig.description,
       params: {
         blockType: block.type,
-        inputMapping: assembleCustomBlockInputMapping(block.params || {}),
+        inputMapping,
       },
       parameters: buildCustomBlockInputMappingSchema(
         blockDef.name,

apps/sim/tools/index.ts

@@ -1251,6 +1251,9 @@ export async function executeTool(
       const endTime = new Date()
       return {
         ...result,
+        // Strip internal `__`-prefixed fields the same way every other tool path does,
+        // so child-workflow internals never reach the agent's tool result.
+        output: postProcessToolOutput(normalizedToolId, result.output ?? {}),
         timing: {
           startTime: startTimeISO,
           endTime: endTime.toISOString(),