fix(mothership): preserve composed code export outcomes

Author: Sg312

apps/sim/lib/function-execution/execute-request.ts

@@ -81,6 +81,7 @@ import {
 } from '@/lib/execution/remote-sandbox/sandbox-paths'
 import type { SandboxCollectedFile, SandboxFile } from '@/lib/execution/remote-sandbox/types'
 import { isExecutionResourceLimitError } from '@/lib/execution/resource-errors'
+import type { SandboxExportedFile } from '@/lib/function-execution/output'
 import { planUserFileMounts, resolveUserFileMounts } from '@/lib/function-execution/sandbox-mounts'
 import {
   FORMAT_TO_CONTENT_TYPE,
@@ -1464,18 +1465,6 @@ function workspaceFileExportErrorStatus(error: unknown): number {
   return asOrchestrationError(error)?.code === 'forbidden' ? 403 : 400
 }
 
-interface SandboxExportedFile {
-  fileId: string
-  fileName: string
-  vfsPath: string
-  downloadUrl?: string
-  sandboxPath?: string
-  size: number
-  previousSize?: number
-  sha256: string
-  unchanged: boolean
-}
-
 /**
  * Builds the success response for a sandbox file export.
  *

apps/sim/lib/function-execution/output.ts

@@ -0,0 +1,17 @@
+/** Receipt for a workspace file explicitly exported by code execution. */
+export interface SandboxExportedFile {
+  fileId: string
+  fileName: string
+  vfsPath: string
+  downloadUrl?: string
+  sandboxPath?: string
+  size: number
+  previousSize?: number
+  sha256: string
+  unchanged: boolean
+}
+
+export interface SandboxExportReceipt {
+  message: string
+  files: SandboxExportedFile[]
+}

apps/sim/lib/mothership/agent-cli/saved-run-read.postgres.test.ts

@@ -159,7 +159,7 @@ describe('maybeWriteOutputToFile', () => {
     expect(mockWriteWorkspaceFileByPath).not.toHaveBeenCalled()
   })
 
-  it('does not deny a read-only principal when no workspace write occurs (sandbox export active)', async () => {
+  it('passes through sandbox-only receipts without attempting another workspace write', async () => {
     const exportedResult = {
       success: true,
       output: {
@@ -175,7 +175,13 @@ describe('maybeWriteOutputToFile', () => {
 
     const result = await maybeWriteOutputToFile(
       RunFunction.id,
-      { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
+      {
+        outputs: {
+          files: [
+            { path: 'files/report.csv', mode: 'overwrite', sandboxPath: '/home/user/report.csv' },
+          ],
+        },
+      },
       exportedResult,
       buildContext({ userPermission: 'read' })
     )
@@ -188,18 +194,55 @@ describe('maybeWriteOutputToFile', () => {
     const result = await maybeWriteOutputToFile(
       RunFunction.id,
       { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
-      { success: true, output: { result: 'name,age\nAlice,30', stdout: '' } },
+      { success: true, output: { result: 'name,age\nAlice,30', stdout: 'Exported 1 row' } },
       buildContext()
     )
 
     expect(result.success).toBe(true)
+    expect(result.output).toMatchObject({ stdout: 'Exported 1 row' })
     expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledTimes(1)
     expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({ secretProvenance: { status: 'exact', entries: [] } })
     )
   })
 
+  it('writes returned data alongside a completed sandbox export and keeps both receipts', async () => {
+    const existingFile = { fileId: 'raw-file', fileName: 'raw.csv', vfsPath: 'files/raw.csv' }
+    const existingResource = {
+      type: 'file' as const,
+      id: 'raw-file',
+      title: 'raw.csv',
+      path: 'files/raw.csv',
+    }
+    const result = await maybeWriteOutputToFile(
+      RunFunction.id,
+      {
+        outputs: {
+          files: [
+            { path: 'files/raw.csv', sandboxPath: '/home/user/raw.csv' },
+            { path: 'files/report.csv' },
+          ],
+        },
+      },
+      {
+        success: true,
+        output: { result: [{ name: 'Ada' }], stdout: '1 row', exported: { files: [existingFile] } },
+        resources: [existingResource],
+      },
+      buildContext()
+    )
+
+    expect(mockWriteWorkspaceFileByPath).toHaveBeenCalledTimes(1)
+    expect(mockWriteWorkspaceFileByPath.mock.calls[0]?.[1].buffer.toString()).toBe('name\nAda')
+    expect(result.output).toMatchObject({
+      result: [{ name: 'Ada' }],
+      stdout: '1 row',
+      files: [existingFile, expect.objectContaining({ vfsPath: 'files/report.csv' })],
+    })
+    expect(result.resources).toContainEqual(existingResource)
+  })
+
   it('classifies large structured output from its serialized bytes instead of its object count', async () => {
     const registry = new ResolvedSecretTraceRegistry(
       [

apps/sim/lib/mothership/request/tools/files.test.ts

@@ -28,6 +28,13 @@ import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secr
 const logger = createLogger('CopilotToolResultFiles')
 const MAX_OUTPUT_FILE_PROVENANCE_REPRESENTATIONS = 10_000
 
+/** Reads durable file receipts from code exports or returned-value file writes. */
+export function getOutputFileReceipts(output: unknown): Record<string, unknown>[] {
+  if (!isRecordLike(output)) return []
+  const files = isRecordLike(output.exported) ? output.exported.files : output.files
+  return Array.isArray(files) ? files.filter(isRecordLike) : []
+}
+
 export const OUTPUT_PATH_TOOLS: Set<string> = new Set([RunFunction.id, UserTable.id])
 
 export type OutputFormat = 'json' | 'csv' | 'txt' | 'md' | 'html'
@@ -355,13 +362,7 @@ export async function maybeWriteOutputToFile(
   const outputObject = isRecordLike(result.output)
     ? (result.output as Record<string, unknown>)
     : undefined
-  if (isRecordLike(outputObject?.exported)) {
-    logger.warn('Skipping returned-value output write because sandbox export response is active', {
-      toolName,
-      outputCount: outputFiles.length,
-    })
-    return result
-  }
+  const previousFiles = getOutputFileReceipts(result.output)
 
   const denied = denyOutputWriteWithoutWritePermission(context)
   if (denied) return denied
@@ -467,35 +468,43 @@ export async function maybeWriteOutputToFile(
           })),
         })
 
+        const files = [
+          ...previousFiles,
+          ...writtenFiles.map((file) => ({
+            fileId: file.id,
+            fileName: file.name,
+            vfsPath: file.vfsPath,
+            size: file.bytes,
+            downloadUrl: file.downloadUrl,
+          })),
+        ]
         return {
           success: true,
           output: {
             // The computed value stays on the result so a table write declared on the
             // same call (`outputTable`) still has rows to read after the file write.
             result: outputObject?.result,
+            ...(typeof outputObject?.stdout === 'string' ? { stdout: outputObject.stdout } : {}),
             message:
               writtenFiles.length === 1
                 ? `Output ${firstWritten.mode === 'overwrite' ? 'updated' : 'written'} at ${firstWritten.vfsPath} (${firstWritten.bytes} bytes)`
                 : `Output written to ${writtenFiles.length} files`,
-            files: writtenFiles.map((file) => ({
-              fileId: file.id,
-              fileName: file.name,
-              vfsPath: file.vfsPath,
-              size: file.bytes,
-              downloadUrl: file.downloadUrl,
-            })),
+            files,
             fileId: firstWritten.id,
             fileName: firstWritten.name,
             vfsPath: firstWritten.vfsPath,
             size: firstWritten.bytes,
             downloadUrl: firstWritten.downloadUrl,
           },
-          resources: writtenFiles.map((file) => ({
-            type: 'file',
-            id: file.id,
-            title: file.name,
-            path: file.vfsPath,
-          })),
+          resources: [
+            ...(result.resources ?? []),
+            ...writtenFiles.map((file) => ({
+              type: 'file' as const,
+              id: file.id,
+              title: file.name,
+              path: file.vfsPath,
+            })),
+          ],
         }
       } catch (err) {
         const message = toError(err).message

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

@@ -51,14 +51,15 @@ const table: TableDefinition = {
   workspaceId: 'workspace-1',
   createdBy: 'user-1',
   archivedAt: null,
+  locks: { schemaLocked: false, insertLocked: false, updateLocked: false, deleteLocked: false },
   createdAt: new Date('2026-08-01T00:00:00.000Z'),
   updatedAt: new Date('2026-08-01T00:00:00.000Z'),
 }
 
 const tableLogger = vi.mocked(loggerMock.createLogger).mock.results[
   vi
     .mocked(loggerMock.createLogger)
-    .mock.calls.findIndex(([name]) => name === 'CopilotToolResultTables')
+    .mock.calls.findIndex((call: readonly unknown[]) => call[0] === 'CopilotToolResultTables')
 ]?.value
 
 function buildContext(overrides: Partial<ExecutionContext> = {}): ExecutionContext {
@@ -256,6 +257,25 @@ describe('automatic Copilot tool-output table persistence', () => {
     expect(mocks.executeReplace).not.toHaveBeenCalled()
   })
 
+  it('keeps committed file receipts when the table application command throws', async () => {
+    const files = [{ fileId: 'file-1', vfsPath: 'files/report.csv' }]
+    mocks.executeReplace.mockRejectedValueOnce(new Error('database unavailable'))
+
+    const result = await maybeWriteOutputToTable(
+      RunFunction.id,
+      { outputTable: 'table-1' },
+      { success: true, output: { result: [{ name: 'Ada' }], exported: { files } } },
+      buildContext()
+    )
+
+    expect(result).toEqual({
+      success: false,
+      error:
+        'Failed to write to table: Table operation failed. The declared output files were already written.',
+      output: { files },
+    })
+  })
+
   it('tells each language how to hand rows back when the shape is wrong', async () => {
     const result = await maybeWriteOutputToTable(
       RunFunction.id,

apps/sim/lib/mothership/request/tools/tables.test.ts

@@ -9,6 +9,7 @@ import { TraceAttr } from '@/lib/mothership/generated/trace-attributes-v1'
 import { TraceEvent } from '@/lib/mothership/generated/trace-events-v1'
 import { TraceSpan } from '@/lib/mothership/generated/trace-spans-v1'
 import { withCopilotSpan } from '@/lib/mothership/request/otel'
+import { getOutputFileReceipts } from '@/lib/mothership/request/tools/files'
 import { denyOutputWriteWithoutWritePermission } from '@/lib/mothership/request/tools/permissions'
 import { projectToolErrorMessageForCopilot } from '@/lib/mothership/request/tools/resolved-secret-result'
 import type { ExecutionContext, ToolCallResult } from '@/lib/mothership/request/types'
@@ -22,17 +23,6 @@ const MAX_OUTPUT_TABLE_ROWS = 10_000
 const RETURN_ROWS_HINT = 'JavaScript: `return [...]`; Python: assign `__sim_result__ = [...]`'
 const ARRAY_OF_OBJECTS_ERROR = `outputTable requires the code to return an array of objects (${RETURN_ROWS_HINT})`
 
-/**
- * The sandbox export receipt `execute-request` places beside the returned value
- * (`output.exported.files`), or the bare `files` an older receipt carried at the
- * top level. Empty when the run exported nothing.
- */
-function exportedFiles(rawOutput: unknown): Record<string, unknown>[] {
-  if (!isRecordLike(rawOutput)) return []
-  const files = isRecordLike(rawOutput.exported) ? rawOutput.exported.files : rawOutput.files
-  return Array.isArray(files) ? files.filter(isRecordLike) : []
-}
-
 /** What the code printed, when it printed anything. */
 function printedStdout(rawOutput: unknown): string | undefined {
   if (!isRecordLike(rawOutput)) return undefined
@@ -47,7 +37,7 @@ function printedStdout(rawOutput: unknown): string | undefined {
  * files so the caller sees what landed instead of re-running the code for it.
  */
 function outputTableFailure(error: string, rawOutput: unknown): ToolCallResult {
-  const files = exportedFiles(rawOutput)
+  const files = getOutputFileReceipts(rawOutput)
   if (files.length === 0) return { success: false, error }
   return {
     success: false,
@@ -179,7 +169,7 @@ export async function maybeWriteOutputToTable(
          * The table result replaces the run's output, so the export receipt rides along
          * or the agent has to `files list` to confirm a write it already made.
          */
-        const exported = exportedFiles(rawOutput)
+        const exported = getOutputFileReceipts(rawOutput)
         const stdout = printedStdout(rawOutput)
         const exportNote =
           exported.length > 0
@@ -217,10 +207,7 @@ export async function maybeWriteOutputToTable(
         span.addEvent(TraceEvent.CopilotTableError, {
           [TraceAttr.ErrorMessage]: projectedMessage.slice(0, 500),
         })
-        return {
-          success: false,
-          error: `Failed to write to table: ${projectedMessage}`,
-        }
+        return outputTableFailure(`Failed to write to table: ${projectedMessage}`, result.output)
       }
     }
   )

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

@@ -137,6 +137,31 @@ describe('Function Execute Tool', () => {
     })
   })
 
+  it('preserves explicit workspace export receipts alongside the computed value', async () => {
+    const exported = {
+      message: 'Exported report.csv',
+      files: [
+        {
+          fileId: 'file-1',
+          fileName: 'report.csv',
+          vfsPath: 'files/report.csv',
+          size: 12,
+          sha256: 'digest',
+          unchanged: false,
+        },
+      ],
+    }
+    const result = await functionExecuteTool.transformResponse?.(
+      Response.json({
+        success: true,
+        output: { result: [{ count: 2 }], stdout: 'done', exported },
+      }),
+      { code: 'return [{ count: 2 }]' }
+    )
+    expect(result?.output).toMatchObject({ result: [{ count: 2 }], stdout: 'done', exported })
+    expect(result?.output.files).toEqual([])
+  })
+
   it('preserves sandbox cost in a failed Function result', async () => {
     const cost = { input: 0, output: 0, total: 0.00012345 }
     const result = await functionExecuteTool.transformResponse?.(

apps/sim/tools/function/execute.test.ts

@@ -264,6 +264,7 @@ To return a file from a Function sandbox, write it to ${SANDBOX_OUTPUT_DIR}. In
         result: result.output.result,
         stdout: result.output.stdout,
         files: result.output.files ?? [],
+        ...(result.output.exported ? { exported: result.output.exported } : {}),
         ...(result.output.cost ? { cost: result.output.cost } : {}),
         ...(result.output.sandboxSession ? { sandboxSession: result.output.sandboxSession } : {}),
       },

apps/sim/tools/function/execute.ts

@@ -1,5 +1,6 @@
 import type { CodeLanguage } from '@/lib/execution/languages'
 import type { PrivateSecretProvenanceBundleV1 } from '@/lib/execution/model-input-provenance'
+import type { SandboxExportReceipt } from '@/lib/function-execution/output'
 import type { UserFile } from '@/executor/types'
 import type { ToolResponse } from '@/tools/types'
 
@@ -91,6 +92,8 @@ export interface CodeExecutionOutput extends ToolResponse {
     stdout: string
     /** Files harvested from the sandbox output directory, already persisted. */
     files: UserFile[]
+    /** Explicit workspace exports survive adapter projection for Mothership post-processing. */
+    exported?: SandboxExportReceipt
     cost?: {
       input: number
       output: number