fix(execution): address review regressions

Author: icecrasher321

apps/sim/app/api/mcp/tools/execute/route.test.ts

@@ -171,6 +171,8 @@ describe('MCP tool execution private secret provenance', () => {
     const response = await POST(request, {})
     const body = (await response.json()) as Record<string, unknown>
 
+    expect(response.status).toBe(500)
+    expect(response.ok).toBe(false)
     expect(body).toEqual({
       success: false,
       error: 'Internal MCP response could not be verified',

apps/sim/app/api/mcp/tools/execute/route.ts

@@ -72,6 +72,7 @@ async function attachPrivateProvenance(
   provenance: ResolvedSecretTraceProvenanceAccumulator
 ): Promise<NextResponse> {
   let payload: Record<string, unknown>
+  let status = response.status
   try {
     const body = await readResponseToBufferWithLimit(response, {
       maxBytes: MAX_PRIVATE_MCP_RESPONSE_BYTES,
@@ -85,6 +86,7 @@ async function attachPrivateProvenance(
     payload = parsed as Record<string, unknown>
   } catch {
     payload = { success: false, error: 'Internal MCP response could not be verified' }
+    status = 500
     provenance.markIncomplete({ discardEntries: true })
   }
 
@@ -93,7 +95,7 @@ async function attachPrivateProvenance(
   headers.set(PRIVATE_TOOL_METADATA_RESPONSE_HEADER, RESOLVED_SECRET_PROVENANCE_METADATA_V1)
   return NextResponse.json(
     { ...payload, [RESOLVED_SECRET_PROVENANCE_FIELD]: provenance.exportProvenance() },
-    { status: response.status, headers }
+    { status, headers }
   )
 }
 

apps/sim/app/api/workflows/[id]/execute/route.async.test.ts

@@ -374,6 +374,49 @@ describe('workflow execute async route', () => {
     )
   })
 
+  it('recovers legacy starter input by execution ID without returning it to the client', async () => {
+    const sourceInput = { token: 'legacy-retry-input', nested: { value: 42 } }
+    queueTableRows(schemaMock.workflowExecutionLogs, [
+      {
+        executionId: 'source-execution',
+        workflowId: 'workflow-1',
+        workspaceId: 'workspace-1',
+        executionData: {
+          executionState: {
+            blockStates: {
+              start: {
+                output: sourceInput,
+                executed: false,
+                executionTime: 0,
+              },
+            },
+          },
+        },
+      },
+    ])
+    const request = createMockRequest(
+      'POST',
+      { inputFromExecutionId: 'source-execution' },
+      {
+        'Content-Type': 'application/json',
+        'X-Execution-Mode': 'async',
+        Cookie: 'session=value',
+      }
+    )
+
+    const response = await POST(request, { params: Promise.resolve({ id: 'workflow-1' }) })
+    const responseBody = await response.json()
+
+    expect(response.status).toBe(202)
+    expect(responseBody).not.toHaveProperty('input')
+    expect(JSON.stringify(responseBody)).not.toContain('legacy-retry-input')
+    expect(mockEnqueue).toHaveBeenCalledWith(
+      'workflow-execution',
+      expect.objectContaining({ input: sourceInput }),
+      expect.any(Object)
+    )
+  })
+
   it('rejects client input alongside a stored execution input reference', async () => {
     const response = await POST(
       createMockRequest(

apps/sim/lib/workflows/executor/execution-state.test.ts

@@ -112,6 +112,66 @@ describe('execution state lookup', () => {
     })
   })
 
+  it('recovers legacy workflow input from the pre-populated starter block state', async () => {
+    const legacyInput = { leadId: 'legacy-lead' }
+    queueTableRows(schemaMock.workflowExecutionLogs, [
+      {
+        executionId: 'execution-1',
+        workflowId: 'workflow-1',
+        workspaceId: 'workspace-1',
+        executionData: {},
+      },
+    ])
+    mockMaterializeExecutionData.mockResolvedValueOnce({
+      executionState: {
+        blockStates: {
+          'executed-block': {
+            output: { leadId: 'wrong-lead' },
+            executed: true,
+            executionTime: 10,
+          },
+          start: {
+            output: legacyInput,
+            executed: false,
+            executionTime: 0,
+          },
+        },
+      },
+    })
+
+    const result = await getExecutionInputForWorkflow('execution-1', 'workflow-1')
+
+    expect(result).toEqual({ found: true, input: legacyInput })
+  })
+
+  it('prefers persisted workflow input over the legacy starter block state', async () => {
+    const workflowInput = { leadId: 'current-lead' }
+    queueTableRows(schemaMock.workflowExecutionLogs, [
+      {
+        executionId: 'execution-1',
+        workflowId: 'workflow-1',
+        workspaceId: 'workspace-1',
+        executionData: {},
+      },
+    ])
+    mockMaterializeExecutionData.mockResolvedValueOnce({
+      workflowInput,
+      executionState: {
+        blockStates: {
+          start: {
+            output: { leadId: 'legacy-lead' },
+            executed: false,
+            executionTime: 0,
+          },
+        },
+      },
+    })
+
+    const result = await getExecutionInputForWorkflow('execution-1', 'workflow-1')
+
+    expect(result).toEqual({ found: true, input: workflowInput })
+  })
+
   it('checks older pointer-backed candidates when the latest has no execution state', async () => {
     queueTableRows(schemaMock.workflowExecutionLogs, [
       {

apps/sim/lib/workflows/executor/execution-state.ts

@@ -1,5 +1,6 @@
 import { db } from '@sim/db'
 import { workflowExecutionLogs } from '@sim/db/schema'
+import { isRecordLike } from '@sim/utils/object'
 import { and, desc, eq, or, sql } from 'drizzle-orm'
 import { materializeExecutionData, TRACE_STORE_REF_KEY } from '@/lib/logs/execution/trace-store'
 import type { SerializableExecutionState } from '@/executor/execution/types'
@@ -30,6 +31,25 @@ function extractExecutionState(executionData: unknown): SerializableExecutionSta
   return isSerializableExecutionState(state) ? state : null
 }
 
+function extractLegacyWorkflowInput(executionData: Record<string, unknown>): unknown | undefined {
+  if (!isRecordLike(executionData.executionState)) return undefined
+  const { blockStates } = executionData.executionState
+  if (!isRecordLike(blockStates)) return undefined
+
+  for (const state of Object.values(blockStates)) {
+    if (
+      isRecordLike(state) &&
+      state.executed === false &&
+      state.executionTime === 0 &&
+      state.output != null
+    ) {
+      return state.output
+    }
+  }
+
+  return undefined
+}
+
 interface ExecutionStateRow {
   executionId: string
   workflowId: string | null
@@ -109,7 +129,11 @@ export async function getExecutionInputForWorkflow(
   }
 
   const data = await materializeExecutionDataFromRow(row)
-  return { found: true, input: data?.workflowInput }
+  if (!data) return { found: true }
+  if (Object.hasOwn(data, 'workflowInput')) {
+    return { found: true, input: data.workflowInput }
+  }
+  return { found: true, input: extractLegacyWorkflowInput(data) }
 }
 
 export async function getLatestExecutionStateWithExecutionId(