Fix start.files

Author: Sg312

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

@@ -359,6 +359,7 @@ async function handleExecutePost(
       includeFileBase64,
       base64MaxBytes,
       workflowStateOverride,
+      executionId: requestedExecutionId,
       triggerBlockId: parsedTriggerBlockId,
       startBlockId,
       stopAfterBlockId,
@@ -508,7 +509,8 @@ async function handleExecutePost(
       )
     }
 
-    const executionId = generateId()
+    const executionId =
+      isClientSession && requestedExecutionId ? requestedExecutionId : generateId()
     reqLogger = reqLogger.withMetadata({ userId, executionId })
 
     reqLogger.info('Starting server-side execution', {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts

@@ -524,6 +524,7 @@ export function useWorkflowExecution() {
                       size: fileData.file.size,
                       type: fileData.file.type,
                       key: result.key,
+                      context: 'execution',
                     })
                   } catch (uploadError) {
                     if (
@@ -565,6 +566,7 @@ export function useWorkflowExecution() {
                         size: r.size,
                         type: r.type,
                         key: r.key,
+                        context: r.context || 'execution',
                         uploadedAt: r.uploadedAt,
                         expiresAt: r.expiresAt,
                       })
@@ -1126,6 +1128,7 @@ export function useWorkflowExecution() {
         await executionStream.execute({
           workflowId: activeWorkflowId,
           input: finalWorkflowInput,
+          executionId,
           startBlockId,
           selectedOutputs,
           triggerType: overrideTriggerType || 'manual',

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts

@@ -903,6 +903,7 @@ export async function executeWorkflowWithFullLogging(
     triggerType: options.overrideTriggerType || 'manual',
     useDraftState: options.useDraftState ?? true,
     isClientSession: true,
+    ...(options.executionId ? { executionId: options.executionId } : {}),
     ...(options.triggerBlockId ? { triggerBlockId: options.triggerBlockId } : {}),
     ...(options.stopAfterBlockId ? { stopAfterBlockId: options.stopAfterBlockId } : {}),
     ...(options.runFromBlock

apps/sim/executor/handlers/agent/agent-handler.ts

@@ -39,7 +39,7 @@ import { buildAPIUrl, buildAuthHeaders } from '@/executor/utils/http'
 import { stringifyJSON } from '@/executor/utils/json'
 import { resolveVertexCredential } from '@/executor/utils/vertex-credential'
 import { executeProviderRequest } from '@/providers'
-import { getAttachmentProvider, getProviderAttachmentMaxBytes } from '@/providers/attachments'
+import { getProviderAttachmentMaxBytes, supportsFileAttachments } from '@/providers/attachments'
 import { getProviderFromModel, transformBlockTool } from '@/providers/utils'
 import type { SerializedBlock } from '@/serializer/types'
 import { filterSchemaForLLM, type ToolSchema } from '@/tools/params'
@@ -91,10 +91,14 @@ export class AgentBlockHandler implements BlockHandler {
 
     const streamingConfig = this.getStreamingConfig(ctx, block)
     const messages = await this.buildMessages(ctx, filteredInputs, skillMetadata)
-    const messagesWithFiles = await this.attachFilesToLastUserMessage(
+    const messagesWithInputFiles = this.attachFilesToLastUserMessage(
       ctx,
       messages,
-      filteredInputs.files,
+      filteredInputs.files
+    )
+    const messagesWithFiles = await this.hydrateMessageFilesForProvider(
+      ctx,
+      messagesWithInputFiles,
       providerId
     )
 
@@ -682,12 +686,11 @@ export class AgentBlockHandler implements BlockHandler {
     return messages.length > 0 ? messages : undefined
   }
 
-  private async attachFilesToLastUserMessage(
+  private attachFilesToLastUserMessage(
     ctx: ExecutionContext,
     messages: Message[] | undefined,
-    filesInput: unknown,
-    providerId: string
-  ): Promise<Message[] | undefined> {
+    filesInput: unknown
+  ): Message[] | undefined {
     const normalizedFiles = normalizeFileInput(filesInput)
     if (!normalizedFiles || normalizedFiles.length === 0) {
       return messages
@@ -697,10 +700,6 @@ export class AgentBlockHandler implements BlockHandler {
       throw new Error('Files require at least one user message in the agent prompt')
     }
 
-    if (!getAttachmentProvider(providerId)) {
-      throw new Error(`File attachments are not supported for provider "${providerId}"`)
-    }
-
     let lastUserMessageIndex = -1
     for (let index = messages.length - 1; index >= 0; index--) {
       if (messages[index].role === 'user') {
@@ -718,21 +717,71 @@ export class AgentBlockHandler implements BlockHandler {
       throw new Error('Files must include at least one valid file object')
     }
 
-    const hydratedFiles = await hydrateUserFilesWithBase64(userFiles, {
-      requestId,
-      workspaceId: ctx.workspaceId,
-      workflowId: ctx.workflowId,
-      executionId: ctx.executionId,
-      userId: ctx.userId,
-      logger,
-      maxBytes: getProviderAttachmentMaxBytes(providerId),
-    })
-
     const lastUserMessage = messages[lastUserMessageIndex]
     const nextMessages = [...messages]
     nextMessages[lastUserMessageIndex] = {
       ...lastUserMessage,
-      files: [...(lastUserMessage.files ?? []), ...hydratedFiles],
+      files: [...(lastUserMessage.files ?? []), ...userFiles],
+    }
+
+    return nextMessages
+  }
+
+  private async hydrateMessageFilesForProvider(
+    ctx: ExecutionContext,
+    messages: Message[] | undefined,
+    providerId: string
+  ): Promise<Message[] | undefined> {
+    if (!messages?.some((message) => message.files?.length)) {
+      return messages
+    }
+
+    if (!supportsFileAttachments(providerId)) {
+      throw new Error(`File attachments are not supported for provider "${providerId}"`)
+    }
+
+    const requestId = ctx.executionId || ctx.workflowId || 'agent-files'
+    const nextMessages = [...messages]
+
+    for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+      const message = messages[messageIndex]
+      const normalizedFiles = normalizeFileInput(message.files)
+      if (!normalizedFiles || normalizedFiles.length === 0) {
+        continue
+      }
+
+      const userFiles = processFilesToUserFiles(
+        normalizedFiles as RawFileInput[],
+        requestId,
+        logger
+      )
+      if (userFiles.length === 0) {
+        throw new Error('Files must include at least one valid file object')
+      }
+
+      const hydratedFiles = await hydrateUserFilesWithBase64(userFiles, {
+        requestId,
+        workspaceId: ctx.workspaceId,
+        workflowId: ctx.workflowId,
+        executionId: ctx.executionId,
+        largeValueExecutionIds: ctx.largeValueExecutionIds,
+        allowLargeValueWorkflowScope: ctx.allowLargeValueWorkflowScope,
+        userId: ctx.userId,
+        logger,
+        maxBytes: getProviderAttachmentMaxBytes(providerId),
+      })
+
+      const missingFile = hydratedFiles.find((file) => !file.base64)
+      if (missingFile) {
+        throw new Error(
+          `File "${missingFile.name}" could not be read for provider "${providerId}". Make sure the file is still accessible and under the provider attachment size limit.`
+        )
+      }
+
+      nextMessages[messageIndex] = {
+        ...message,
+        files: hydratedFiles,
+      }
     }
 
     return nextMessages

apps/sim/executor/handlers/agent/memory.test.ts

@@ -178,6 +178,34 @@ describe('Memory', () => {
     })
   })
 
+  describe('sanitizeMessageForStorage', () => {
+    it('should strip file payloads and provider-only fields before memory persistence', () => {
+      const message: Message = {
+        role: 'user',
+        content: 'Analyze this file',
+        executionId: 'exec-1',
+        files: [
+          {
+            id: 'file-1',
+            key: 'workspace/ws-1/example.png',
+            name: 'example.png',
+            url: '/api/files/serve/workspace%2Fws-1%2Fexample.png?context=workspace',
+            size: 128,
+            type: 'image/png',
+            base64: 'iVBORw0KGgo=',
+          },
+        ],
+        tool_calls: [{ id: 'call-1' }],
+      }
+
+      expect((memoryService as any).sanitizeMessageForStorage(message)).toEqual({
+        role: 'user',
+        content: 'Analyze this file',
+        executionId: 'exec-1',
+      })
+    })
+  })
+
   describe('Token-based vs Message-based comparison', () => {
     it('should produce different results for same limit concept', () => {
       const messages: Message[] = [

apps/sim/executor/handlers/agent/memory.ts

@@ -122,6 +122,14 @@ export class Memory {
     return messages.slice(-limit)
   }
 
+  private sanitizeMessageForStorage(message: Message): Message {
+    return {
+      role: message.role,
+      content: message.content,
+      ...(message.executionId && { executionId: message.executionId }),
+    }
+  }
+
   private applyTokenWindow(messages: Message[], maxTokens: number, model?: string): Message[] {
     const result: Message[] = []
     let tokenCount = 0
@@ -177,9 +185,17 @@ export class Memory {
     const data = result[0].data
     if (!Array.isArray(data)) return []
 
-    return data.filter(
-      (msg): msg is Message => msg && typeof msg === 'object' && 'role' in msg && 'content' in msg
-    )
+    return data
+      .filter(
+        (msg): msg is Message =>
+          msg &&
+          typeof msg === 'object' &&
+          'role' in msg &&
+          'content' in msg &&
+          ['system', 'user', 'assistant'].includes(msg.role) &&
+          typeof msg.content === 'string'
+      )
+      .map((msg) => this.sanitizeMessageForStorage(msg))
   }
 
   private async seedMemoryRecord(
@@ -189,13 +205,15 @@ export class Memory {
   ): Promise<void> {
     const now = new Date()
 
+    const sanitizedMessages = messages.map((message) => this.sanitizeMessageForStorage(message))
+
     await db
       .insert(memory)
       .values({
         id: generateId(),
         workspaceId,
         key,
-        data: messages,
+        data: sanitizedMessages,
         createdAt: now,
         updatedAt: now,
       })
@@ -205,20 +223,22 @@ export class Memory {
   private async appendMessage(workspaceId: string, key: string, message: Message): Promise<void> {
     const now = new Date()
 
+    const sanitizedMessage = this.sanitizeMessageForStorage(message)
+
     await db
       .insert(memory)
       .values({
         id: generateId(),
         workspaceId,
         key,
-        data: [message],
+        data: [sanitizedMessage],
         createdAt: now,
         updatedAt: now,
       })
       .onConflictDoUpdate({
         target: [memory.workspaceId, memory.key],
         set: {
-          data: sql`${memory.data} || ${JSON.stringify([message])}::jsonb`,
+          data: sql`${memory.data} || ${JSON.stringify([sanitizedMessage])}::jsonb`,
           updatedAt: now,
         },
       })

apps/sim/executor/utils/start-block.test.ts

@@ -119,6 +119,42 @@ describe('start-block utilities', () => {
     expect(output.files).toEqual(files)
   })
 
+  it.concurrent('buildStartBlockOutput normalizes Start files from internal serve URLs', () => {
+    const block = createBlock('start_trigger', 'start')
+    const resolution = {
+      blockId: 'start',
+      block,
+      path: StartBlockPath.UNIFIED,
+    } as const
+
+    const output = buildStartBlockOutput({
+      resolution,
+      workflowInput: {
+        files: [
+          {
+            id: 'file_1',
+            name: 'screenshot.png',
+            url: '/api/files/serve/s3/execution%2Fworkspace-id%2Fworkflow-id%2Fexecution-id%2Fscreenshot.png?context=execution',
+            size: 243289,
+            type: 'image/png',
+          },
+        ],
+      },
+    })
+
+    expect(output.files).toEqual([
+      {
+        id: 'file_1',
+        name: 'screenshot.png',
+        url: '/api/files/serve/s3/execution%2Fworkspace-id%2Fworkflow-id%2Fexecution-id%2Fscreenshot.png?context=execution',
+        size: 243289,
+        type: 'image/png',
+        key: 'execution/workspace-id/workflow-id/execution-id/screenshot.png',
+        context: 'execution',
+      },
+    ])
+  })
+
   it.concurrent('rejects inputFormat fields that collide with executor routing keys', () => {
     const block = createBlock('start_trigger', 'start', {
       subBlocks: {