fix(mothership): leave an unencodable block output for the projection to refuse

The output bound handles size only. A block output JSON cannot encode cannot be checked, so it is
no longer sized past the budget and replaced with a pointer; the projection refuses it as it did
before this PR.

Author: waleedlatif1

apps/sim/lib/mothership/tools/handlers/workflow/run-workflow-result-budget.test.ts

@@ -450,4 +450,34 @@ describe('run_workflow model-facing result budget', () => {
     expect(output.output).toEqual(expect.stringContaining(`logs get ${EXECUTION_ID} --trace`))
     expect(output.outputFrom).toEqual({ blockId: 'query', blockName: 'Query' })
   })
+
+  /**
+   * The bound only handles size. An output JSON cannot encode cannot be checked, so the run is still
+   * refused rather than the value being hidden behind a pointer.
+   */
+  it('still refuses a run with an unencodable block output while bounding bulky ones', async () => {
+    mocks.executeWorkflowUseCase.mockResolvedValue({
+      success: true,
+      output: {},
+      logs: [
+        {
+          blockId: 'big',
+          blockName: 'Big',
+          success: true,
+          output: { rows: tableRows(4_800, 3_200_000) },
+        },
+        { blockId: 'odd', blockName: 'Odd', success: true, output: { count: 1n } },
+      ],
+      metadata: { executionId: EXECUTION_ID },
+    })
+
+    const settled = await executeRunWorkflowUntilBlock(
+      { workflowId: 'wf-1', stopAfterBlockId: 'odd' },
+      context
+    )
+    const presented = settled.output as { output: unknown; logs: Array<{ output: unknown }> }
+    expect(presented.output).toEqual({ count: 1n })
+    expect(presented.logs[1]?.output).toEqual({ count: 1n })
+    expect(inspectToolResultForCopilot(settled, registry, 'run_workflow').safe).toBe(false)
+  })
 })

apps/sim/lib/mothership/tools/workflow-output.ts

@@ -122,12 +122,14 @@ interface BlockOutputSize {
 
 /**
  * Sizes one block output for the budgets. An output past a projection limit (values, bytes, or
- * depth) or one JSON cannot encode would be refused whatever else the result holds, so it is
- * sized past every budget and is always the first to be replaced.
+ * depth) would be refused whatever else the result holds, so it is sized past every budget and is
+ * always the first to be replaced. One JSON cannot encode is not a size problem: it returns
+ * undefined and is left for the projection to refuse, as it always has been.
  */
-function sizeBlockOutput(output: unknown): BlockOutputSize {
+function sizeBlockOutput(output: unknown): BlockOutputSize | undefined {
   const measure = measureModelContent(output)
-  if (!measure || measure.exceeded) {
+  if (!measure) return undefined
+  if (measure.exceeded) {
     return {
       values: MAX_CONTENT_NODES + 1,
       bytes: MAX_MODEL_CONTENT_BYTES + 1,
@@ -158,6 +160,7 @@ function compactBlockLogOutputs(logs: unknown, executionId: string | undefined):
   for (const [index, entry] of logs.entries()) {
     if (!isPlainRecord(entry) || entry.output === undefined) continue
     const size = sizeBlockOutput(entry.output)
+    if (!size) continue
     measured.push({ index, entry, ...size })
     values += size.values
     bytes += size.bytes
@@ -195,5 +198,6 @@ export function boundRunResultForModel(
   )
   // A result JSON cannot encode is refused whatever its size, so only one past a cap is bounded.
   if (!whole?.exceeded) return data
-  return { ...data, output: blockOutputPointer(sizeBlockOutput(data.output).label, executionId) }
+  const size = sizeBlockOutput(data.output)
+  return size ? { ...data, output: blockOutputPointer(size.label, executionId) } : data
 }