Add file support to agent chat (#13187)

https://github.com/user-attachments/assets/911d5d8d-cc2e-4c18-9f93-2663d84ff9ef

---------

Co-authored-by: Raphaël Bosi <71827178+bosiraphael@users.noreply.github.com>
Co-authored-by: neo773 <62795688+neo773@users.noreply.github.com>
Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>
Co-authored-by: Félix Malfait <felix.malfait@gmail.com>
Co-authored-by: Félix Malfait <felix@twenty.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions <github-actions@twenty.com>
Co-authored-by: MD Readul Islam <99027968+readul-islam@users.noreply.github.com>
Co-authored-by: readul-islam <developer.readul@gamil.com>
Co-authored-by: Thomas des Francs <tdesfrancs@gmail.com>
Co-authored-by: Guillim <guillim@users.noreply.github.com>
Co-authored-by: Lucas Bordeau <bordeau.lucas@gmail.com>

packages/twenty-server/src/database/commands/cron-register-all.command.ts

@@ -2,6 +2,7 @@ import { Logger } from '@nestjs/common';
 
 import { Command, CommandRunner } from 'nest-commander';
 
+import { CleanupOrphanedFilesCronCommand } from 'src/engine/core-modules/file/crons/commands/cleanup-orphaned-files.cron.command';
 import { CalendarEventListFetchCronCommand } from 'src/modules/calendar/calendar-event-import-manager/crons/commands/calendar-event-list-fetch.cron.command';
 import { CalendarEventsImportCronCommand } from 'src/modules/calendar/calendar-event-import-manager/crons/commands/calendar-import.cron.command';
 import { CalendarOngoingStaleCronCommand } from 'src/modules/calendar/calendar-event-import-manager/crons/commands/calendar-ongoing-stale.cron.command';
@@ -25,6 +26,7 @@ export class CronRegisterAllCommand extends CommandRunner {
     private readonly calendarEventsImportCronCommand: CalendarEventsImportCronCommand,
     private readonly calendarOngoingStaleCronCommand: CalendarOngoingStaleCronCommand,
     private readonly cronTriggerCronCommand: CronTriggerCronCommand,
+    private readonly cleanupOrphanedFilesCronCommand: CleanupOrphanedFilesCronCommand,
   ) {
     super();
   }
@@ -58,6 +60,10 @@ export class CronRegisterAllCommand extends CommandRunner {
         command: this.calendarOngoingStaleCronCommand,
       },
       { name: 'CronTrigger', command: this.cronTriggerCronCommand },
+      {
+        name: 'CleanupOrphanedFiles',
+        command: this.cleanupOrphanedFilesCronCommand,
+      },
     ];
 
     let successCount = 0;

packages/twenty-server/src/database/commands/database-command.module.ts

@@ -5,6 +5,7 @@ import { ConfirmationQuestion } from 'src/database/commands/questions/confirmati
 import { UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/upgrade-version-command.module';
 import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
 import { ApiKeyModule } from 'src/engine/core-modules/api-key/api-key.module';
+import { FileModule } from 'src/engine/core-modules/file/file.module';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
 import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/field-metadata.module';
 import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
@@ -25,6 +26,7 @@ import { DataSeedWorkspaceCommand } from './data-seed-dev-workspace.command';
     MessagingImportManagerModule,
     CalendarEventImportManagerModule,
     AutomatedTriggerModule,
+    FileModule,
 
     // Data seeding dependencies
     TypeORMModule,

packages/twenty-server/src/database/typeorm/core/migrations/common/1752207396042-create-file-table.ts

@@ -0,0 +1,31 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateFileTable1752207396042 implements MigrationInterface {
+  name = 'CreateFileTable1752207396042';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "core"."file" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" character varying NOT NULL, "fullPath" character varying NOT NULL, "size" bigint NOT NULL, "type" character varying NOT NULL, "workspaceId" uuid NOT NULL, "messageId" uuid, "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), CONSTRAINT "PK_36b46d232307066b3a2c9ea3a1d" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_FILE_WORKSPACE_ID" ON "core"."file" ("workspaceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "core"."file" ADD CONSTRAINT "FK_de468b3d8dcf7e94f7074220929" FOREIGN KEY ("workspaceId") REFERENCES "core"."workspace"("id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "core"."file" ADD CONSTRAINT "FK_a78a68c3f577a485dd4c741909f" FOREIGN KEY ("messageId") REFERENCES "core"."agentChatMessage"("id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "core"."file" DROP CONSTRAINT "FK_a78a68c3f577a485dd4c741909f"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "core"."file" DROP CONSTRAINT "FK_de468b3d8dcf7e94f7074220929"`,
+    );
+    await queryRunner.query(`DROP INDEX "core"."IDX_FILE_WORKSPACE_ID"`);
+    await queryRunner.query(`DROP TABLE "core"."file"`);
+  }
+}

packages/twenty-server/src/engine/core-modules/file/crons/commands/cleanup-orphaned-files.cron.command.ts

@@ -0,0 +1,32 @@
+import { Command, CommandRunner } from 'nest-commander';
+
+import {
+  CLEANUP_ORPHANED_FILES_CRON_PATTERN,
+  CleanupOrphanedFilesCronJob,
+} from 'src/engine/core-modules/file/crons/jobs/cleanup-orphaned-files.cron.job';
+import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
+import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
+
+@Command({
+  name: 'cron:file:cleanup-orphaned-files',
+  description: 'Starts a cron job to clean up orphaned files (no messageId)',
+})
+export class CleanupOrphanedFilesCronCommand extends CommandRunner {
+  constructor(
+    @InjectMessageQueue(MessageQueue.cronQueue)
+    private readonly messageQueueService: MessageQueueService,
+  ) {
+    super();
+  }
+
+  async run(): Promise<void> {
+    await this.messageQueueService.addCron<undefined>({
+      jobName: CleanupOrphanedFilesCronJob.name,
+      data: undefined,
+      options: {
+        repeat: { pattern: CLEANUP_ORPHANED_FILES_CRON_PATTERN },
+      },
+    });
+  }
+}

packages/twenty-server/src/engine/core-modules/file/crons/jobs/cleanup-orphaned-files.cron.job.ts

@@ -0,0 +1,69 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
+import { IsNull, LessThan, Repository } from 'typeorm';
+
+import { SentryCronMonitor } from 'src/engine/core-modules/cron/sentry-cron-monitor.decorator';
+import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FileMetadataService } from 'src/engine/core-modules/file/services/file-metadata.service';
+import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
+import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+
+export const CLEANUP_ORPHANED_FILES_CRON_PATTERN = '0 2 * * *';
+
+@Processor(MessageQueue.cronQueue)
+export class CleanupOrphanedFilesCronJob {
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    private readonly workspaceRepository: Repository<Workspace>,
+    @InjectRepository(FileEntity, 'core')
+    private readonly fileRepository: Repository<FileEntity>,
+    private readonly fileMetadataService: FileMetadataService,
+    private readonly exceptionHandlerService: ExceptionHandlerService,
+  ) {}
+
+  @Process(CleanupOrphanedFilesCronJob.name)
+  @SentryCronMonitor(
+    CleanupOrphanedFilesCronJob.name,
+    CLEANUP_ORPHANED_FILES_CRON_PATTERN,
+  )
+  async handle(): Promise<void> {
+    const activeWorkspaces = await this.workspaceRepository.find({
+      where: {
+        activationStatus: WorkspaceActivationStatus.ACTIVE,
+      },
+      select: ['id'],
+    });
+
+    if (activeWorkspaces.length === 0) {
+      return;
+    }
+
+    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
+
+    const orphanedFiles = await this.fileRepository.find({
+      select: ['id', 'workspaceId', 'fullPath'],
+      where: {
+        messageId: IsNull(),
+        createdAt: LessThan(oneHourAgo),
+      },
+    });
+
+    if (orphanedFiles.length === 0) {
+      return;
+    }
+
+    for (const file of orphanedFiles) {
+      await this.fileMetadataService
+        .deleteFileById(file.id, file.workspaceId)
+        .catch((error) => {
+          throw new Error(
+            `[${CleanupOrphanedFilesCronJob.name}] Cannot delete orphaned file - ${file.fullPath}: ${error.message}`,
+          );
+        });
+    }
+  }
+}

packages/twenty-server/src/engine/core-modules/file/dtos/file.dto.ts

@@ -0,0 +1,25 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('File')
+export class FileDTO {
+  @Field(() => ID)
+  id: string;
+
+  @Field()
+  name: string;
+
+  @Field()
+  fullPath: string;
+
+  @Field()
+  size: number;
+
+  @Field()
+  type: string;
+
+  @Field(() => ID, { nullable: true })
+  messageId?: string;
+
+  @Field()
+  createdAt: Date;
+}

packages/twenty-server/src/engine/core-modules/file/entities/file.entity.ts

@@ -0,0 +1,53 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  Relation,
+} from 'typeorm';
+
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AgentChatMessageEntity } from 'src/engine/metadata-modules/agent/agent-chat-message.entity';
+
+@Entity('file')
+@Index('IDX_FILE_WORKSPACE_ID', ['workspaceId'])
+export class FileEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ nullable: false })
+  name: string;
+
+  @Column({ nullable: false })
+  fullPath: string;
+
+  @Column({ nullable: false, type: 'bigint' })
+  size: number;
+
+  @Column({ nullable: false })
+  type: string;
+
+  @Column({ nullable: false, type: 'uuid' })
+  workspaceId: string;
+
+  @ManyToOne(() => Workspace, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'workspaceId' })
+  workspace: Relation<Workspace>;
+
+  @Column({ nullable: true, type: 'uuid' })
+  messageId: string;
+
+  @ManyToOne(() => AgentChatMessageEntity, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'messageId' })
+  message: Relation<AgentChatMessageEntity>;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt: Date;
+}

packages/twenty-server/src/engine/core-modules/file/file.module.ts

@@ -1,4 +1,6 @@
+import { HttpModule } from '@nestjs/axios';
 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { FilePathGuard } from 'src/engine/core-modules/file/guards/file-path-guard';
 import { FileDeletionJob } from 'src/engine/core-modules/file/jobs/file-deletion.job';
@@ -6,21 +8,37 @@ import { FileWorkspaceFolderDeletionJob } from 'src/engine/core-modules/file/job
 import { FileAttachmentListener } from 'src/engine/core-modules/file/listeners/file-attachment.listener';
 import { FileWorkspaceMemberListener } from 'src/engine/core-modules/file/listeners/file-workspace-member.listener';
 import { JwtModule } from 'src/engine/core-modules/jwt/jwt.module';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 
 import { FileController } from './controllers/file.controller';
+import { CleanupOrphanedFilesCronCommand } from './crons/commands/cleanup-orphaned-files.cron.command';
+import { CleanupOrphanedFilesCronJob } from './crons/jobs/cleanup-orphaned-files.cron.job';
+import { FileEntity } from './entities/file.entity';
+import { FileUploadService } from './file-upload/services/file-upload.service';
+import { FileResolver } from './resolvers/file.resolver';
+import { FileMetadataService } from './services/file-metadata.service';
 import { FileService } from './services/file.service';
 
 @Module({
-  imports: [JwtModule],
+  imports: [
+    JwtModule,
+    TypeOrmModule.forFeature([FileEntity, Workspace], 'core'),
+    HttpModule,
+  ],
   providers: [
     FileService,
+    FileMetadataService,
+    FileResolver,
     FilePathGuard,
     FileAttachmentListener,
     FileWorkspaceMemberListener,
     FileWorkspaceFolderDeletionJob,
     FileDeletionJob,
+    CleanupOrphanedFilesCronJob,
+    CleanupOrphanedFilesCronCommand,
+    FileUploadService,
   ],
-  exports: [FileService],
+  exports: [FileService, FileMetadataService, CleanupOrphanedFilesCronCommand],
   controllers: [FileController],
 })
 export class FileModule {}

packages/twenty-server/src/engine/core-modules/file/interfaces/file-folder.interface.ts

@@ -8,6 +8,7 @@ export enum FileFolder {
   Attachment = 'attachment',
   PersonPicture = 'person-picture',
   ServerlessFunction = 'serverless-function',
+  File = 'file',
 }
 
 registerEnumType(FileFolder, {
@@ -34,6 +35,9 @@ export const fileFolderConfigs: Record<FileFolder, FileFolderConfig> = {
   [FileFolder.ServerlessFunction]: {
     ignoreExpirationToken: false,
   },
+  [FileFolder.File]: {
+    ignoreExpirationToken: false,
+  },
 };
 
 export type AllowedFolders = KebabCase<keyof typeof FileFolder>;

packages/twenty-server/src/engine/core-modules/file/jobs/file-deletion.job.ts

@@ -1,6 +1,7 @@
 import { UnrecoverableError } from 'bullmq';
 
 import { FileService } from 'src/engine/core-modules/file/services/file.service';
+import { extractFolderPathAndFilename } from 'src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
@@ -18,8 +19,7 @@ export class FileDeletionJob {
   async handle(data: FileDeletionJobData): Promise<void> {
     const { workspaceId, fullPath } = data;
 
-    const folderPath = fullPath.split('/').slice(0, -1).join('/');
-    const filename = fullPath.split('/').pop();
+    const { folderPath, filename } = extractFolderPathAndFilename(fullPath);
 
     if (!filename) {
       throw new UnrecoverableError(

packages/twenty-server/src/engine/core-modules/file/resolvers/file.resolver.ts

@@ -0,0 +1,55 @@
+import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
+import { Args, Mutation, Resolver } from '@nestjs/graphql';
+
+import { FileUpload, GraphQLUpload } from 'graphql-upload';
+
+import { FileDTO } from 'src/engine/core-modules/file/dtos/file.dto';
+import { FileMetadataService } from 'src/engine/core-modules/file/services/file-metadata.service';
+import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
+import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { streamToBuffer } from 'src/utils/stream-to-buffer';
+
+@UseGuards(WorkspaceAuthGuard)
+@UsePipes(ResolverValidationPipe)
+@UseFilters(PreventNestToAutoLogGraphqlErrorsFilter)
+@Resolver()
+export class FileResolver {
+  constructor(private readonly fileMetadataService: FileMetadataService) {}
+
+  @Mutation(() => FileDTO)
+  async createFile(
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+    @Args({ name: 'file', type: () => GraphQLUpload })
+    { createReadStream, filename, mimetype }: FileUpload,
+  ): Promise<FileDTO> {
+    const stream = createReadStream();
+    const buffer = await streamToBuffer(stream);
+
+    return this.fileMetadataService.createFile({
+      file: buffer,
+      filename,
+      mimeType: mimetype,
+      workspaceId,
+    });
+  }
+
+  @Mutation(() => FileDTO)
+  async deleteFile(
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+    @Args('fileId') fileId: string,
+  ): Promise<FileDTO> {
+    const deletedFile = await this.fileMetadataService.deleteFileById(
+      fileId,
+      workspaceId,
+    );
+
+    if (!deletedFile) {
+      throw new Error(`File with id ${fileId} not found`);
+    }
+
+    return deletedFile;
+  }
+}

packages/twenty-server/src/engine/core-modules/file/services/file-metadata.service.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import { FileFolder } from 'src/engine/core-modules/file/interfaces/file-folder.interface';
+
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { FileDTO } from 'src/engine/core-modules/file/dtos/file.dto';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FileUploadService } from 'src/engine/core-modules/file/file-upload/services/file-upload.service';
+import { extractFolderPathAndFilename } from 'src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils';
+
+import { FileService } from './file.service';
+
+@Injectable()
+export class FileMetadataService {
+  constructor(
+    @InjectRepository(FileEntity, 'core')
+    private readonly fileRepository: Repository<FileEntity>,
+    private readonly fileService: FileService,
+    private readonly fileStorageService: FileStorageService,
+    private readonly fileUploadService: FileUploadService,
+  ) {}
+
+  async createFile({
+    file,
+    filename,
+    mimeType,
+    workspaceId,
+  }: {
+    file: Buffer;
+    filename: string;
+    mimeType: string;
+    workspaceId: string;
+  }): Promise<FileDTO> {
+    const { files } = await this.fileUploadService.uploadFile({
+      file,
+      filename,
+      mimeType,
+      fileFolder: FileFolder.File,
+      workspaceId,
+    });
+
+    if (!files.length) {
+      throw new Error('Failed to upload file');
+    }
+
+    const createdFile = this.fileRepository.create({
+      name: filename,
+      fullPath: files[0].path,
+      size: file.length,
+      type: mimeType,
+      workspaceId,
+    });
+
+    const savedFile = await this.fileRepository.save(createdFile);
+
+    return savedFile;
+  }
+
+  async deleteFileById(
+    id: string,
+    workspaceId: string,
+  ): Promise<FileDTO | null> {
+    const file = await this.fileRepository.findOne({
+      where: { id, workspaceId },
+    });
+
+    if (!file) {
+      return null;
+    }
+
+    const { folderPath, filename } = extractFolderPathAndFilename(
+      file.fullPath,
+    );
+
+    try {
+      if (file.fullPath) {
+        await this.fileService.deleteFile({
+          folderPath,
+          filename,
+          workspaceId,
+        });
+      }
+
+      await this.fileRepository.delete(file.id);
+
+      return file;
+    } catch (error) {
+      throw new Error(`Failed to delete file ${id}: ${error.message}`);
+    }
+  }
+}

packages/twenty-server/src/engine/core-modules/file/services/file.service.ts

@@ -3,18 +3,18 @@ import { Injectable } from '@nestjs/common';
 import { basename, dirname, extname } from 'path';
 import { Stream } from 'stream';
 
-import { v4 as uuidV4 } from 'uuid';
-import { buildSignedPath } from 'twenty-shared/utils';
 import { isNonEmptyString } from '@sniptt/guards';
+import { buildSignedPath } from 'twenty-shared/utils';
+import { v4 as uuidV4 } from 'uuid';
 
-import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
-import { JwtWrapperService } from 'src/engine/core-modules/jwt/services/jwt-wrapper.service';
-import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
-import { extractFilenameFromPath } from 'src/engine/core-modules/file/utils/extract-file-id-from-path.utils';
 import {
   FileTokenJwtPayload,
   JwtTokenTypeEnum,
 } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { extractFolderPathAndFilename } from 'src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils';
+import { JwtWrapperService } from 'src/engine/core-modules/jwt/services/jwt-wrapper.service';
+import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 
 @Injectable()
 export class FileService {
@@ -45,7 +45,7 @@ export class FileService {
     return buildSignedPath({
       path: url,
       token: this.encodeFileToken({
-        filename: extractFilenameFromPath(url),
+        filename: extractFolderPathAndFilename(url).filename,
         workspaceId,
       }),
     });

packages/twenty-server/src/engine/core-modules/file/utils/__tests__/extract-file-id-from-path.utils.spec.ts

@@ -1,37 +0,0 @@
-import { extractFilenameFromPath } from 'src/engine/core-modules/file/utils/extract-file-id-from-path.utils';
-
-describe('extractFileIdFromPath', () => {
-  it('should return the last segment of a normal path', () => {
-    const result = extractFilenameFromPath('uploads/files/1234.txt');
-
-    expect(result).toBe('1234.txt');
-  });
-
-  it('should return the last segment when there is no slash', () => {
-    const result = extractFilenameFromPath('file.txt');
-
-    expect(result).toBe('file.txt');
-  });
-
-  it('should throw when empty path', () => {
-    expect(() => extractFilenameFromPath('')).toThrow(
-      new Error('Cannot extract id from empty path'),
-    );
-  });
-
-  it('should throw when empty filename', () => {
-    const folderPath = 'uploads/files/';
-
-    expect(() => extractFilenameFromPath(folderPath)).toThrow(
-      new Error(`Cannot extract id from folder path '${folderPath}'`),
-    );
-  });
-
-  it('should throw when empty filename absolute path', () => {
-    const folderPath = '/a/b/c/';
-
-    expect(() => extractFilenameFromPath(folderPath)).toThrow(
-      new Error(`Cannot extract id from folder path '${folderPath}'`),
-    );
-  });
-});

packages/twenty-server/src/engine/core-modules/file/utils/extract-file-id-from-path.utils.ts

@@ -1,17 +0,0 @@
-import { basename } from 'path';
-
-import { isNonEmptyString } from '@sniptt/guards';
-
-export const extractFilenameFromPath = (path: string) => {
-  if (path.endsWith('/')) {
-    throw new Error(`Cannot extract id from folder path '${path}'`);
-  }
-
-  const fileId = basename(path);
-
-  if (!isNonEmptyString(fileId)) {
-    throw new Error(`Cannot extract id from empty path`);
-  }
-
-  return fileId;
-};

packages/twenty-server/src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils.ts

@@ -0,0 +1,13 @@
+export function extractFolderPathAndFilename(fullPath: string): {
+  folderPath: string;
+  filename: string;
+} {
+  if (!fullPath || typeof fullPath !== 'string') {
+    throw new Error('Invalid fullPath provided');
+  }
+  const parts = fullPath.split('/');
+  const filename = parts.pop() || '';
+  const folderPath = parts.join('/');
+
+  return { folderPath, filename };
+}

packages/twenty-server/src/engine/metadata-modules/agent/agent-chat-message.entity.ts

@@ -5,10 +5,12 @@ import {
   Index,
   JoinColumn,
   ManyToOne,
+  OneToMany,
   PrimaryGeneratedColumn,
   Relation,
 } from 'typeorm';
 
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
 import { AgentChatThreadEntity } from 'src/engine/metadata-modules/agent/agent-chat-thread.entity';
 
 export enum AgentChatMessageRole {
@@ -37,6 +39,9 @@ export class AgentChatMessageEntity {
   @Column('text')
   content: string;
 
+  @OneToMany(() => FileEntity, (file) => file.message)
+  files: Relation<FileEntity[]>;
+
   @CreateDateColumn()
   createdAt: Date;
 }

packages/twenty-server/src/engine/metadata-modules/agent/agent-chat.controller.ts

@@ -58,7 +58,7 @@ export class AgentChatController {
   @Post('stream')
   async streamAgentChat(
     @Body()
-    body: { threadId: string; userMessage: string },
+    body: { threadId: string; userMessage: string; fileIds?: string[] },
     @AuthUserWorkspaceId() userWorkspaceId: string,
     @Res() res: Response,
   ) {
@@ -67,6 +67,7 @@ export class AgentChatController {
         threadId: body.threadId,
         userMessage: body.userMessage,
         userWorkspaceId,
+        fileIds: body.fileIds || [],
         res,
       });
     } catch (error) {

packages/twenty-server/src/engine/metadata-modules/agent/agent-chat.service.ts

@@ -3,6 +3,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 
 import { Repository } from 'typeorm';
 
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
 import {
   AgentChatMessageEntity,
   AgentChatMessageRole,
@@ -20,6 +21,8 @@ export class AgentChatService {
     private readonly threadRepository: Repository<AgentChatThreadEntity>,
     @InjectRepository(AgentChatMessageEntity, 'core')
     private readonly messageRepository: Repository<AgentChatMessageEntity>,
+    @InjectRepository(FileEntity, 'core')
+    private readonly fileRepository: Repository<FileEntity>,
   ) {}
 
   async createThread(agentId: string, userWorkspaceId: string) {
@@ -45,10 +48,12 @@ export class AgentChatService {
     threadId,
     role,
     content,
+    fileIds,
   }: {
     threadId: string;
     role: AgentChatMessageRole;
     content: string;
+    fileIds?: string[];
   }) {
     const message = this.messageRepository.create({
       threadId,
@@ -56,7 +61,17 @@ export class AgentChatService {
       content,
     });
 
-    return this.messageRepository.save(message);
+    const savedMessage = await this.messageRepository.save(message);
+
+    if (fileIds && fileIds.length > 0) {
+      for (const fileId of fileIds) {
+        await this.fileRepository.update(fileId, {
+          messageId: savedMessage.id,
+        });
+      }
+    }
+
+    return savedMessage;
   }
 
   async getMessagesForThread(threadId: string, userWorkspaceId: string) {
@@ -77,6 +92,7 @@ export class AgentChatService {
     return this.messageRepository.find({
       where: { threadId },
       order: { createdAt: 'ASC' },
+      relations: ['files'],
     });
   }
 }

packages/twenty-server/src/engine/metadata-modules/agent/agent-execution.service.ts

@@ -1,16 +1,30 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 
+import { Readable } from 'stream';
+
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createOpenAI } from '@ai-sdk/openai';
-import { CoreMessage, generateObject, generateText, streamText } from 'ai';
-import { Repository } from 'typeorm';
+import {
+  CoreMessage,
+  CoreUserMessage,
+  FilePart,
+  generateObject,
+  generateText,
+  ImagePart,
+  streamText,
+  TextPart,
+} from 'ai';
+import { In, Repository } from 'typeorm';
 
 import {
   ModelId,
   ModelProvider,
 } from 'src/engine/core-modules/ai/constants/ai-models.const';
 import { AiModelRegistryService } from 'src/engine/core-modules/ai/services/ai-model-registry.service';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FileService } from 'src/engine/core-modules/file/services/file.service';
+import { extractFolderPathAndFilename } from 'src/engine/core-modules/file/utils/extract-folderpath-and-filename.utils';
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 import {
   AgentChatMessageEntity,
@@ -22,6 +36,7 @@ import { AGENT_SYSTEM_PROMPTS } from 'src/engine/metadata-modules/agent/constant
 import { convertOutputSchemaToZod } from 'src/engine/metadata-modules/agent/utils/convert-output-schema-to-zod';
 import { OutputSchema } from 'src/modules/workflow/workflow-builder/workflow-schema/types/output-schema.type';
 import { resolveInput } from 'src/modules/workflow/workflow-executor/utils/variable-resolver.util';
+import { streamToBuffer } from 'src/utils/stream-to-buffer';
 
 import { AgentEntity } from './agent.entity';
 import { AgentException, AgentExceptionCode } from './agent.exception';
@@ -45,9 +60,12 @@ export class AgentExecutionService {
   constructor(
     private readonly twentyConfigService: TwentyConfigService,
     private readonly agentToolService: AgentToolService,
+    private readonly fileService: FileService,
     private readonly aiModelRegistryService: AiModelRegistryService,
     @InjectRepository(AgentEntity, 'core')
     private readonly agentRepository: Repository<AgentEntity>,
+    @InjectRepository(FileEntity, 'core')
+    private readonly fileRepository: Repository<FileEntity>,
   ) {}
 
   getModel = (modelId: ModelId, provider: ModelProvider) => {
@@ -58,9 +76,7 @@ export class AgentExecutionService {
           apiKey: this.twentyConfigService.get('OPENAI_COMPATIBLE_API_KEY'),
         });
 
-        return OpenAIProvider(
-          this.aiModelRegistryService.getEffectiveModelConfig(modelId).modelId,
-        );
+        return OpenAIProvider(modelId);
       }
       case ModelProvider.OPENAI: {
         const OpenAIProvider = createOpenAI({
@@ -167,14 +183,73 @@ export class AgentExecutionService {
     }
   }
 
+  private async buildUserMessageWithFiles(
+    userMessage: string,
+    fileIds?: string[],
+  ): Promise<CoreUserMessage> {
+    if (!fileIds || fileIds.length === 0) {
+      return { role: AgentChatMessageRole.USER, content: userMessage };
+    }
+
+    const files = await this.fileRepository.find({
+      where: {
+        id: In(fileIds),
+      },
+    });
+
+    const textPart: TextPart = {
+      type: 'text',
+      text: userMessage,
+    };
+
+    const fileParts = await Promise.all(
+      files.map((file) => this.createFilePart(file)),
+    );
+
+    return {
+      role: AgentChatMessageRole.USER,
+      content: [textPart, ...fileParts],
+    };
+  }
+
+  private async createFilePart(
+    file: FileEntity,
+  ): Promise<ImagePart | FilePart> {
+    const { folderPath, filename } = extractFolderPathAndFilename(
+      file.fullPath,
+    );
+    const fileStream = await this.fileService.getFileStream(
+      folderPath,
+      filename,
+      file.workspaceId,
+    );
+    const fileBuffer = await streamToBuffer(fileStream as Readable);
+
+    if (file.type.startsWith('image')) {
+      return {
+        type: 'image',
+        image: fileBuffer,
+        mimeType: file.type,
+      };
+    } else {
+      return {
+        type: 'file',
+        data: fileBuffer,
+        mimeType: file.type,
+      };
+    }
+  }
+
   async streamChatResponse({
     agentId,
     userMessage,
     messages,
+    fileIds,
   }: {
     agentId: string;
     userMessage: string;
     messages: AgentChatMessageEntity[];
+    fileIds?: string[];
   }) {
     const agent = await this.agentRepository.findOneOrFail({
       where: { id: agentId },
@@ -185,10 +260,12 @@ export class AgentExecutionService {
       content,
     }));
 
-    llmMessages.push({
-      role: AgentChatMessageRole.USER,
-      content: userMessage,
-    });
+    const userMessageWithFiles = await this.buildUserMessageWithFiles(
+      userMessage,
+      fileIds,
+    );
+
+    llmMessages.push(userMessageWithFiles);
 
     const aiRequestConfig = await this.prepareAIRequestConfig({
       system: `${AGENT_SYSTEM_PROMPTS.AGENT_CHAT}\n\n${agent.prompt}`,

packages/twenty-server/src/engine/metadata-modules/agent/agent-streaming.service.ts

@@ -17,6 +17,7 @@ export type StreamAgentChatOptions = {
   threadId: string;
   userMessage: string;
   userWorkspaceId: string;
+  fileIds?: string[];
   res: Response;
 };
 
@@ -41,6 +42,7 @@ export class AgentStreamingService {
     threadId,
     userMessage,
     userWorkspaceId,
+    fileIds = [],
     res,
   }: StreamAgentChatOptions) {
     try {
@@ -59,12 +61,6 @@ export class AgentStreamingService {
         );
       }
 
-      await this.agentChatService.addMessage({
-        threadId,
-        role: AgentChatMessageRole.USER,
-        content: userMessage,
-      });
-
       this.setupStreamingHeaders(res);
 
       const { fullStream } =
@@ -72,6 +68,7 @@ export class AgentStreamingService {
           agentId: thread.agent.id,
           userMessage,
           messages: thread.messages,
+          fileIds,
         });
 
       let aiResponse = '';
@@ -92,6 +89,20 @@ export class AgentStreamingService {
             });
             break;
           case 'error':
+            {
+              const errorMessage =
+                chunk.error &&
+                typeof chunk.error === 'object' &&
+                'message' in chunk.error
+                  ? chunk.error.message
+                  : 'Something went wrong. Please try again.';
+
+              this.sendStreamEvent(res, {
+                type: 'error',
+                message: errorMessage as string,
+              });
+              res.end();
+            }
             this.logger.error(`Stream error: ${JSON.stringify(chunk)}`);
             break;
           default:
@@ -100,6 +111,19 @@ export class AgentStreamingService {
         }
       }
 
+      if (!aiResponse) {
+        res.end();
+
+        return;
+      }
+
+      await this.agentChatService.addMessage({
+        threadId,
+        role: AgentChatMessageRole.USER,
+        content: userMessage,
+        fileIds,
+      });
+
       await this.agentChatService.addMessage({
         threadId,
         role: AgentChatMessageRole.ASSISTANT,

packages/twenty-server/src/engine/metadata-modules/agent/agent.module.ts

@@ -5,6 +5,9 @@ import { AiModule } from 'src/engine/core-modules/ai/ai.module';
 import { AuditModule } from 'src/engine/core-modules/audit/audit.module';
 import { TokenModule } from 'src/engine/core-modules/auth/token/token.module';
 import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FileUploadModule } from 'src/engine/core-modules/file/file-upload/file-upload.module';
+import { FileModule } from 'src/engine/core-modules/file/file.module';
 import { ThrottlerModule } from 'src/engine/core-modules/throttler/throttler.module';
 import { UserWorkspace } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
 import { AgentChatController } from 'src/engine/metadata-modules/agent/agent-chat.controller';
@@ -33,6 +36,7 @@ import { AgentService } from './agent.service';
         RoleTargetsEntity,
         AgentChatMessageEntity,
         AgentChatThreadEntity,
+        FileEntity,
         UserWorkspace,
       ],
       'core',
@@ -41,6 +45,8 @@ import { AgentService } from './agent.service';
     ThrottlerModule,
     AuditModule,
     FeatureFlagModule,
+    FileUploadModule,
+    FileModule,
     ObjectMetadataModule,
     WorkspacePermissionsCacheModule,
     WorkspaceCacheStorageModule,

packages/twenty-server/src/engine/metadata-modules/agent/dtos/agent-chat-message.dto.ts

@@ -1,5 +1,7 @@
 import { Field, ID, ObjectType } from '@nestjs/graphql';
 
+import { FileDTO } from 'src/engine/core-modules/file/dtos/file.dto';
+
 @ObjectType('AgentChatMessage')
 export class AgentChatMessageDTO {
   @Field(() => ID)
@@ -14,6 +16,9 @@ export class AgentChatMessageDTO {
   @Field()
   content: string;
 
+  @Field(() => [FileDTO], { nullable: true })
+  files?: FileDTO[];
+
   @Field()
   createdAt: Date;
 }

packages/twenty-server/src/main.ts

@@ -57,6 +57,7 @@ const bootstrap = async () => {
 
   // Graphql file upload
   app.use(
+    '/graphql',
     graphqlUploadExpress({
       maxFieldSize: bytes(settings.storage.maxFileSize),
       maxFiles: 10,

packages/twenty-server/src/modules/workflow/workflow-builder/workflow-step/workflow-version-step.workspace-service.ts

@@ -619,7 +619,7 @@ export class WorkflowVersionStepWorkspaceService {
         const newAgent = await this.agentService.createOneAgentAndFirstThread(
           {
             label: 'AI Agent Workflow Step',
-            name: 'ai-agent-workflow',
+            name: `ai-agent-workflow-${newStepId}`,
             description: 'Created automatically for workflow step',
             prompt: '',
             modelId: 'auto',
@@ -635,16 +635,6 @@ export class WorkflowVersionStepWorkspaceService {
           );
         }
 
-        const userWorkspaceId =
-          this.scopedWorkspaceContextFactory.create().userWorkspaceId;
-
-        if (userWorkspaceId) {
-          await this.agentChatService.createThread(
-            newAgent.id,
-            userWorkspaceId,
-          );
-        }
-
         return {
           id: newStepId,
           name: 'AI Agent',