Merge branch 'staging' into feat/workspace-files-folders

Author: waleedlatif1

apps/sim/app/api/mothership/execute/route.ts

@@ -51,6 +51,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       chatId,
       messageId: providedMessageId,
       requestId: providedRequestId,
+      fileAttachments,
       workflowId,
       executionId,
     } = validation.data.body
@@ -89,6 +90,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       messageId,
       isHosted: true,
       workspaceContext: workspaceContextWithMothershipTools,
+      ...(fileAttachments && fileAttachments.length > 0 ? { fileAttachments } : {}),
       ...(integrationTools.length > 0 ? { integrationTools } : {}),
       ...(mothershipToolRuntime.tools.length > 0
         ? { mothershipTools: mothershipToolRuntime.tools }

apps/sim/app/api/tools/file/manage/route.ts

@@ -10,7 +10,8 @@ import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { ensureWorkspaceFileFolderPath } from '@/lib/uploads/contexts/workspace/workspace-file-folder-manager'
 import {
   fetchWorkspaceFileBuffer,
-  resolveWorkspaceFileReference,
+  getWorkspaceFile,
+  getWorkspaceFileByName,
   updateWorkspaceFileContent,
   uploadWorkspaceFile,
 } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
@@ -42,6 +43,51 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
   try {
     switch (body.operation) {
+      case 'get': {
+        const { fileId, fileInput } = body
+        const selectedFileId =
+          fileId ||
+          (fileInput && typeof fileInput === 'object' && !Array.isArray(fileInput)
+            ? typeof fileInput.id === 'string'
+              ? fileInput.id
+              : typeof fileInput.fileId === 'string'
+                ? fileInput.fileId
+                : ''
+            : '')
+
+        if (!selectedFileId) {
+          return NextResponse.json({ success: false, error: 'File is required' }, { status: 400 })
+        }
+
+        const file = await getWorkspaceFile(workspaceId, selectedFileId)
+        if (!file) {
+          return NextResponse.json(
+            { success: false, error: `File not found: "${selectedFileId}"` },
+            { status: 404 }
+          )
+        }
+
+        logger.info('File retrieved', {
+          fileId: file.id,
+          name: file.name,
+        })
+
+        return NextResponse.json({
+          success: true,
+          data: {
+            file: {
+              id: file.id,
+              name: file.name,
+              url: ensureAbsoluteUrl(file.path),
+              size: file.size,
+              type: file.type,
+              key: file.key,
+              context: 'workspace',
+            },
+          },
+        })
+      }
+
       case 'write': {
         const { fileName, content, contentType } = body
         const { folderSegments, leafName } = splitWorkspaceFilePath(fileName)

apps/sim/blocks/blocks/file.ts

@@ -266,6 +266,7 @@ export const FileV3Block: BlockConfig<FileParserV3Output> = {
       type: 'dropdown' as SubBlockType,
       options: [
         { label: 'Read', id: 'file_parser_v3' },
+        { label: 'Get', id: 'file_get' },
         { label: 'Write', id: 'file_write' },
         { label: 'Append', id: 'file_append' },
       ],
@@ -294,6 +295,28 @@ export const FileV3Block: BlockConfig<FileParserV3Output> = {
       required: { field: 'operation', value: 'file_parser_v3' },
       condition: { field: 'operation', value: 'file_parser_v3' },
     },
+    {
+      id: 'getFile',
+      title: 'File',
+      type: 'file-upload' as SubBlockType,
+      canonicalParamId: 'getFileInput',
+      acceptedTypes: '*',
+      placeholder: 'Select a workspace file',
+      multiple: false,
+      mode: 'basic',
+      condition: { field: 'operation', value: 'file_get' },
+      required: { field: 'operation', value: 'file_get' },
+    },
+    {
+      id: 'getFileId',
+      title: 'File ID',
+      type: 'short-input' as SubBlockType,
+      canonicalParamId: 'getFileInput',
+      placeholder: 'Workspace file ID',
+      mode: 'advanced',
+      condition: { field: 'operation', value: 'file_get' },
+      required: { field: 'operation', value: 'file_get' },
+    },
     {
       id: 'fileName',
       title: 'File Name',
@@ -349,7 +372,7 @@ export const FileV3Block: BlockConfig<FileParserV3Output> = {
     },
   ],
   tools: {
-    access: ['file_parser_v3', 'file_write', 'file_append'],
+    access: ['file_parser_v3', 'file_get', 'file_write', 'file_append'],
     config: {
       tool: (params) => params.operation || 'file_parser_v3',
       params: (params) => {
@@ -390,6 +413,25 @@ export const FileV3Block: BlockConfig<FileParserV3Output> = {
           }
         }
 
+        if (operation === 'file_get') {
+          const getInput = params.getFileInput
+          if (!getInput) {
+            throw new Error('File is required for get')
+          }
+
+          if (typeof getInput === 'string') {
+            return {
+              fileId: getInput.trim(),
+              workspaceId: params._context?.workspaceId,
+            }
+          }
+
+          return {
+            fileInput: normalizeFileInput(getInput, { single: true }),
+            workspaceId: params._context?.workspaceId,
+          }
+        }
+
         const fileInput = params.fileInput
         if (!fileInput) {
           logger.error('No file input provided')
@@ -428,9 +470,13 @@ export const FileV3Block: BlockConfig<FileParserV3Output> = {
     },
   },
   inputs: {
-    operation: { type: 'string', description: 'Operation to perform (read, write, or append)' },
+    operation: {
+      type: 'string',
+      description: 'Operation to perform (read, get, write, or append)',
+    },
     fileInput: { type: 'json', description: 'File input for read' },
     fileType: { type: 'string', description: 'File type for read' },
+    getFileInput: { type: 'json', description: 'Selected file or workspace file ID for get' },
     fileName: { type: 'string', description: 'Name for a new file (write)' },
     content: { type: 'string', description: 'File content to write' },
     contentType: { type: 'string', description: 'MIME content type for write' },
@@ -446,6 +492,10 @@ export const FileV3Block: BlockConfig<FileParserV3Output> = {
       type: 'string',
       description: 'All file contents merged into a single text string (read)',
     },
+    file: {
+      type: 'file',
+      description: 'Workspace file object (get)',
+    },
     id: {
       type: 'string',
       description: 'File ID (write)',

apps/sim/blocks/blocks/mothership.ts

@@ -41,6 +41,25 @@ export const MothershipBlock: BlockConfig<MothershipResponse> = {
       type: 'short-input',
       placeholder: 'e.g., user-123, session-abc, customer-456',
     },
+    {
+      id: 'attachmentFiles',
+      title: 'Attachments',
+      type: 'file-upload',
+      canonicalParamId: 'files',
+      placeholder: 'Upload files to attach',
+      mode: 'basic',
+      multiple: true,
+      required: false,
+    },
+    {
+      id: 'fileReferences',
+      title: 'Attachments',
+      type: 'short-input',
+      canonicalParamId: 'files',
+      placeholder: 'Reference files from previous blocks',
+      mode: 'advanced',
+      required: false,
+    },
   ],
   tools: {
     access: [],
@@ -54,6 +73,10 @@ export const MothershipBlock: BlockConfig<MothershipResponse> = {
       type: 'string',
       description: 'Mothership chat ID to continue; generated when omitted',
     },
+    files: {
+      type: 'file',
+      description: 'Files to send to Mothership as attachments',
+    },
   },
   outputs: {
     content: { type: 'string', description: 'Generated response content' },

apps/sim/executor/handlers/mothership/mothership-handler.test.ts

@@ -13,13 +13,15 @@ const {
   mockGenerateId,
   mockIsExecutionCancelled,
   mockIsRedisCancellationEnabled,
+  mockReadUserFileContent,
 } = vi.hoisted(() => ({
   mockBuildAuthHeaders: vi.fn(),
   mockBuildAPIUrl: vi.fn(),
   mockExtractAPIErrorMessage: vi.fn(),
   mockGenerateId: vi.fn(),
   mockIsExecutionCancelled: vi.fn(),
   mockIsRedisCancellationEnabled: vi.fn(),
+  mockReadUserFileContent: vi.fn(),
 }))
 
 vi.mock('@/executor/utils/http', () => ({
@@ -37,6 +39,10 @@ vi.mock('@/lib/execution/cancellation', () => ({
   isRedisCancellationEnabled: mockIsRedisCancellationEnabled,
 }))
 
+vi.mock('@/lib/execution/payloads/materialization.server', () => ({
+  readUserFileContent: mockReadUserFileContent,
+}))
+
 function createAbortError(): Error {
   const error = new Error('The operation was aborted')
   error.name = 'AbortError'
@@ -78,13 +84,14 @@ describe('MothershipBlockHandler', () => {
     mockIsExecutionCancelled.mockReset()
     mockIsRedisCancellationEnabled.mockReset()
     mockIsRedisCancellationEnabled.mockReturnValue(false)
+    mockReadUserFileContent.mockReset()
 
     block = {
       id: 'mothership-block-1',
       metadata: { id: BlockType.MOTHERSHIP, name: 'Mothership' },
       position: { x: 0, y: 0 },
       config: { tool: BlockType.MOTHERSHIP, params: {} },
-      inputs: { prompt: 'string', conversationId: 'string' },
+      inputs: { prompt: 'string', conversationId: 'string', files: 'file[]' },
       outputs: {},
       enabled: true,
     } as SerializedBlock
@@ -212,6 +219,80 @@ describe('MothershipBlockHandler', () => {
     expect(mockGenerateId).toHaveBeenCalledTimes(2)
   })
 
+  it('embeds attached files for the mothership execute request', async () => {
+    const fileContent = Buffer.from('hello mothership', 'utf8').toString('base64')
+    mockGenerateId.mockReturnValueOnce('chat-uuid')
+    mockGenerateId.mockReturnValueOnce('message-uuid')
+    mockGenerateId.mockReturnValueOnce('request-uuid')
+    mockReadUserFileContent.mockResolvedValueOnce(fileContent)
+
+    fetchMock.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          content: 'analyzed',
+          model: 'mothership',
+          conversationId: 'chat-uuid',
+          tokens: {},
+          toolCalls: [],
+        }),
+        {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      )
+    )
+
+    const result = await handler.execute(context, block, {
+      prompt: 'Analyze this file',
+      files: [
+        {
+          name: 'notes.txt',
+          key: 'workspace/workspace-1/notes.txt',
+          size: 16,
+          type: 'text/plain',
+        },
+      ],
+    })
+
+    expect(result).toMatchObject({
+      content: 'analyzed',
+      model: 'mothership',
+      conversationId: 'chat-uuid',
+    })
+    expect(mockReadUserFileContent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: expect.stringMatching(/^file-/),
+        key: 'workspace/workspace-1/notes.txt',
+        name: 'notes.txt',
+        url: '',
+        size: 16,
+        type: 'text/plain',
+      }),
+      expect.objectContaining({
+        encoding: 'base64',
+        userId: 'user-1',
+        workspaceId: 'workspace-1',
+        workflowId: 'workflow-1',
+        executionId: 'execution-1',
+        requestId: 'request-uuid',
+      })
+    )
+
+    const [, options] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const body = JSON.parse(String(options.body))
+    expect(body.fileAttachments).toEqual([
+      {
+        type: 'document',
+        source: {
+          type: 'base64',
+          media_type: 'text/plain',
+          data: fileContent,
+        },
+        filename: 'notes.txt',
+      },
+    ])
+  })
+
   it('propagates local aborts to the mothership request', async () => {
     const abortController = new AbortController()
     context.abortSignal = abortController.signal