fix(mothership): bound run outputs only when the projection walks them against a secret

Without an active secret the model-facing projection passes JSON through under its byte cap
alone, so the block-output budget turned a large lifted run_block output into a pointer for no
reason. Output compaction now applies only when the call's registry makes the projection walk
the result, and a lifted output keeps the final output's share beside the bounded logs.

Author: waleedlatif1

apps/sim/lib/mothership/request/tools/client.ts

@@ -377,7 +377,7 @@ export async function waitForWorkflowToolCompletion({
       ? { output: trustedExecution.finalOutput }
       : {}),
     // Built from raw logs before projection, matching the server handler's presentation.
-    ...presentWorkflowLogsForModel(trustedExecution.blockLogs, executionId, select),
+    ...presentWorkflowLogsForModel(trustedExecution.blockLogs, executionId, toolRegistry, select),
     ...(trustedExecution.error !== undefined ? { error: trustedExecution.error } : {}),
     ...(status === MothershipStreamV1ToolOutcome.cancelled
       ? { reason: 'user_cancelled', cancelledByUser: true }

apps/sim/lib/mothership/request/tools/resolved-secret-result.ts

@@ -1,6 +1,7 @@
 import type { ToolCallEffect, ToolExecutionResult } from '@/lib/mothership/tool-executor/types'
 import { TOOL_EFFECT_PHASE } from '@/lib/mothership/tool-executor/types'
 import {
+  getResolvedSecretModelMatcher,
   measureModelContent,
   projectResolvedSecretModelJsonContent,
 } from '@/executor/utils/resolved-secret-content-projection'
@@ -237,6 +238,23 @@ export function inspectToolResultForCopilot(
   }
 }
 
+/**
+ * Whether {@link inspectToolResultForCopilot} will walk a result under `registry` against active
+ * secrets, and so refuse it past the projection's value and depth caps as well as its byte cap.
+ * With no active secret the projection passes JSON through under the byte cap alone. A registry
+ * the projection cannot use withholds the result anyway, so it counts as walked.
+ */
+export function copilotProjectionWalksContent(
+  registry: ResolvedSecretTraceRegistry | undefined
+): boolean {
+  try {
+    const snapshot = getResolvedSecretModelMatcher(registry?.forkForPropagatedEntries())
+    return !snapshot.complete || snapshot.matcher !== undefined
+  } catch {
+    return true
+  }
+}
+
 /**
  * Projects terminal tool content before it can cross back into Copilot.
  * Runtime output remains unchanged for raw post-processing and context updates.

apps/sim/lib/mothership/tools/handlers/workflow/mutations.ts

@@ -50,6 +50,7 @@ import {
 } from '@/lib/workflows/application/update-workflow-content'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import { hasExecutionResult, readAttemptedExecutionId } from '@/executor/utils/errors'
+import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 import type { WorkflowState } from '@/stores/workflows/workflow/types'
 
 const logger = createLogger('WorkflowMutations')
@@ -138,6 +139,7 @@ function buildExecutionOutput(
     error?: string
     status?: ExecutionResultStatus
   },
+  registry: ResolvedSecretTraceRegistry | undefined,
   phase: ToolEffectPhase,
   extra?: Record<string, unknown>,
   select?: string[]
@@ -154,9 +156,9 @@ function buildExecutionOutput(
       executionId,
       success: result.success,
       ...extra,
-      output: lifted ? compactLiftedBlockOutput(lifted.output, executionId) : output,
+      output: lifted ? compactLiftedBlockOutput(lifted.output, executionId, registry) : output,
       ...(lifted ? { outputFrom: lifted.outputFrom } : {}),
-      ...presentWorkflowLogsForModel(logs, executionId, select),
+      ...presentWorkflowLogsForModel(logs, executionId, registry, select),
     },
     error: result.success
       ? undefined
@@ -189,14 +191,18 @@ function failedBlockError(logs: unknown): string | undefined {
   return undefined
 }
 
-function buildExecutionError(error: unknown): ToolCallResult {
+function buildExecutionError(
+  error: unknown,
+  registry: ResolvedSecretTraceRegistry | undefined
+): ToolCallResult {
   if (hasExecutionResult(error)) {
     return buildExecutionOutput(
       {
         ...error.executionResult,
         success: false,
         error: error.executionResult.error || 'Workflow execution failed',
       },
+      registry,
       settledPhase(error.executionResult.status)
     )
   }
@@ -344,9 +350,15 @@ export async function executeRunWorkflow(
       lifecycle: copilotRunLifecycle(context),
     })
 
-    return buildExecutionOutput(result, settledPhase(result.status), undefined, params.select)
+    return buildExecutionOutput(
+      result,
+      context.resolvedSecretTraceRegistry,
+      settledPhase(result.status),
+      undefined,
+      params.select
+    )
   } catch (error) {
-    return buildExecutionError(error)
+    return buildExecutionError(error, context.resolvedSecretTraceRegistry)
   }
 }
 
@@ -507,12 +519,13 @@ export async function executeRunWorkflowUntilBlock(
 
     return buildExecutionOutput(
       result,
+      context.resolvedSecretTraceRegistry,
       settledPhase(result.status),
       { stoppedAfterBlockId: params.stopAfterBlockId },
       params.select
     )
   } catch (error) {
-    return buildExecutionError(error)
+    return buildExecutionError(error, context.resolvedSecretTraceRegistry)
   }
 }
 
@@ -588,12 +601,13 @@ export async function executeRunFromBlock(
 
     return buildExecutionOutput(
       result,
+      context.resolvedSecretTraceRegistry,
       settledPhase(result.status),
       { startBlockId: params.startBlockId },
       params.select
     )
   } catch (error) {
-    return buildExecutionError(error)
+    return buildExecutionError(error, context.resolvedSecretTraceRegistry)
   }
 }
 
@@ -680,11 +694,12 @@ export async function executeRunBlock(
 
     return buildExecutionOutput(
       result,
+      context.resolvedSecretTraceRegistry,
       settledPhase(result.status),
       { blockId: params.blockId },
       params.select
     )
   } catch (error) {
-    return buildExecutionError(error)
+    return buildExecutionError(error, context.resolvedSecretTraceRegistry)
   }
 }

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

@@ -38,11 +38,16 @@ import {
 
 const EXECUTION_ID = '0f4d5a4c-6a1e-4c2f-9b7d-2c8f1a3e5d90'
 const SECRET = 'fake-secret-for-test-only'
-const context = {
-  userId: 'user-1',
-  workspaceId: 'workspace-1',
-  toolCallId: 'tool-call-1',
-} as ExecutionContext
+
+/** The handler and the projection share the call's registry, as the tool executor wires them. */
+function callContext(registry: ResolvedSecretTraceRegistry) {
+  return {
+    userId: 'user-1',
+    workspaceId: 'workspace-1',
+    toolCallId: 'tool-call-1',
+    resolvedSecretTraceRegistry: registry,
+  } as ExecutionContext
+}
 
 /** Rows and approximate encoded bytes per block of a synthetic trace-shaped run. */
 const TABLE_QUERIES: ReadonlyArray<readonly [rows: number, bytes: number]> = [
@@ -85,17 +90,30 @@ function traceShapedLogs() {
   })
 }
 
-function secretRegistry() {
+/** A configured secret; `active` records that the run resolved it into its result. */
+function secretRegistry({ active = true } = {}) {
   const registry = new ResolvedSecretTraceRegistry([
     { name: 'API_KEY', plaintext: SECRET, encryptedValue: 'ciphertext' },
   ])
-  registry.recordResolved('API_KEY', SECRET, { propagated: true })
+  if (active) registry.recordResolved('API_KEY', SECRET, { propagated: true })
   return registry
 }
 
+/** Row-shaped output of about 27.5k values: past the log budget, under the projection's cap. */
+function wideRows() {
+  return Array.from({ length: 2_500 }, (_, index) =>
+    Object.fromEntries(Array.from({ length: 10 }, (_, column) => [`c${column}`, `r${index}`]))
+  )
+}
+
 describe('run_workflow model-facing result budget', () => {
+  let registry: ResolvedSecretTraceRegistry
+  let context: ExecutionContext
+
   beforeEach(() => {
     mocks.executeWorkflowUseCase.mockReset()
+    registry = secretRegistry()
+    context = callContext(registry)
   })
 
   it('projects a trace-shaped result with an active secret instead of withholding it', async () => {
@@ -110,7 +128,7 @@ describe('run_workflow model-facing result budget', () => {
     })
 
     const settled = await executeRunWorkflow({ workflowId: 'wf-1' }, context)
-    const projection = inspectToolResultForCopilot(settled, secretRegistry(), 'run_workflow')
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
 
     expect(projection.safe).toBe(true)
     const output = projection.result.output as Record<string, unknown>
@@ -140,7 +158,7 @@ describe('run_workflow model-facing result budget', () => {
     })
 
     const settled = await executeRunWorkflow({ workflowId: 'wf-1' }, context)
-    const projection = inspectToolResultForCopilot(settled, secretRegistry(), 'run_workflow')
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
 
     expect(projection.safe).toBe(true)
     expect((projection.result.output as Record<string, unknown>).output).toEqual(finalOutput)
@@ -164,7 +182,7 @@ describe('run_workflow model-facing result budget', () => {
 
     const settled = await executeRunWorkflow({ workflowId: 'wf-1' }, context)
     expect(Buffer.byteLength(JSON.stringify(settled.output))).toBeLessThan(4 * 1024 * 1024)
-    const projection = inspectToolResultForCopilot(settled, secretRegistry(), 'run_workflow')
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
 
     expect(projection.safe).toBe(true)
     expect((projection.result.output as Record<string, unknown>).output).toEqual(finalOutput)
@@ -183,7 +201,7 @@ describe('run_workflow model-facing result budget', () => {
       { workflowId: 'wf-1', select: ['Query 4.rows'] },
       context
     )
-    const projection = inspectToolResultForCopilot(settled, secretRegistry(), 'run_workflow')
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
 
     expect(projection.safe).toBe(true)
     const output = projection.result.output as Record<string, unknown>
@@ -235,7 +253,7 @@ describe('run_workflow model-facing result budget', () => {
       { workflowId: 'wf-1', stopAfterBlockId: 'query' },
       context
     )
-    const projection = inspectToolResultForCopilot(settled, secretRegistry(), 'run_workflow')
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
 
     expect(projection.safe).toBe(true)
     const output = projection.result.output as Record<string, unknown>
@@ -286,7 +304,7 @@ describe('run_workflow model-facing result budget', () => {
     })
 
     const settled = await executeRunWorkflow({ workflowId: 'wf-1' }, context)
-    const projection = inspectToolResultForCopilot(settled, secretRegistry(), 'run_workflow')
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
 
     expect(projection.safe).toBe(true)
     const logs = (projection.result.output as { logs: Array<Record<string, unknown>> }).logs
@@ -313,7 +331,7 @@ describe('run_workflow model-facing result budget', () => {
     })
 
     const settled = await executeRunWorkflow({ workflowId: 'wf-1' }, context)
-    const projection = inspectToolResultForCopilot(settled, secretRegistry(), 'run_workflow')
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
 
     expect(projection.safe).toBe(true)
     const serialized = JSON.stringify(projection.result)
@@ -322,4 +340,59 @@ describe('run_workflow model-facing result budget', () => {
       expect(serialized).not.toContain(SECRET.slice(0, length))
     }
   })
+
+  /**
+   * Without an active secret the projection passes JSON through under its byte cap alone, so
+   * nothing is bounded: a lifted output is the whole point of run_block and reaches the worker in
+   * full, which spills an oversized one to storage for the model to read.
+   */
+  it('returns a large lifted output and its logs in full when no secret is active', async () => {
+    const rows = wideRows()
+    mocks.executeWorkflowUseCase.mockResolvedValue({
+      success: true,
+      output: {},
+      logs: [
+        { blockId: 'start', blockName: 'Start', success: true, output: { ok: true } },
+        { blockId: 'query', blockName: 'Query', success: true, output: { rows } },
+      ],
+      metadata: { executionId: EXECUTION_ID },
+    })
+    const inactive = secretRegistry({ active: false })
+
+    const settled = await executeRunWorkflowUntilBlock(
+      { workflowId: 'wf-1', stopAfterBlockId: 'query' },
+      callContext(inactive)
+    )
+    const projection = inspectToolResultForCopilot(settled, inactive, 'run_workflow')
+
+    expect(projection.safe).toBe(true)
+    const output = projection.result.output as Record<string, unknown>
+    expect(output.output).toEqual({ rows })
+    expect((output.logs as Array<Record<string, unknown>>)[1]?.output).toEqual({ rows })
+  })
+
+  /** A lifted output is the run's final output, so it keeps the final output's larger share. */
+  it('returns a lifted output within the final share in full while a secret is active', async () => {
+    const rows = wideRows()
+    mocks.executeWorkflowUseCase.mockResolvedValue({
+      success: true,
+      output: {},
+      logs: [{ blockId: 'query', blockName: 'Query', success: true, output: { rows } }],
+      metadata: { executionId: EXECUTION_ID },
+    })
+
+    const settled = await executeRunWorkflowUntilBlock(
+      { workflowId: 'wf-1', stopAfterBlockId: 'query' },
+      context
+    )
+    const projection = inspectToolResultForCopilot(settled, registry, 'run_workflow')
+
+    expect(projection.safe).toBe(true)
+    const output = projection.result.output as Record<string, unknown>
+    expect(output.output).toEqual({ rows })
+    // Its log copy is still bounded, so the two together stay under the projection's caps.
+    expect((output.logs as Array<Record<string, unknown>>)[0]?.output).toEqual(
+      expect.stringContaining(`logs get ${EXECUTION_ID} --trace`)
+    )
+  })
 })