Skip to content

The open alternative to Salesforce, designed for AI.

Let the AI chat attach uploaded files to records (#24138)

Thomas Trompettee367cfd23611
diff --git a/packages/twenty-server/src/engine/core-modules/file/files-field/files-field.module.ts b/packages/twenty-server/src/engine/core-modules/file/files-field/files-field.module.ts
index afa7598629b..f93de7043e0 100644
--- a/packages/twenty-server/src/engine/core-modules/file/files-field/files-field.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/file/files-field/files-field.module.ts
@@ -7,8 +7,10 @@ import { FileUrlModule } from 'src/engine/core-modules/file/file-url/file-url.mo
import { FilesFieldDeletionJob } from 'src/engine/core-modules/file/files-field/jobs/files-field-deletion.job';
import { FilesFieldDeletionListener } from 'src/engine/core-modules/file/files-field/listeners/files-field-deletion.listener';
import { FilesFieldResolver } from 'src/engine/core-modules/file/files-field/resolvers/files-field.resolver';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
import { FilesFieldService } from 'src/engine/core-modules/file/files-field/services/files-field.service';
import { JwtModule } from 'src/engine/core-modules/jwt/jwt.module';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
@@ -21,6 +23,7 @@ import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permi
WorkspaceEntity,
ApplicationEntity,
FieldMetadataEntity,
+ FileEntity,
]),
PermissionsModule,
FileStorageModule,
@@ -32,6 +35,7 @@ import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permi
FilesFieldResolver,
FilesFieldDeletionListener,
FilesFieldDeletionJob,
+ provideWorkspaceScopedRepository(FileEntity),
],
exports: [FilesFieldService],
})
diff --git a/packages/twenty-server/src/engine/core-modules/file/files-field/services/__tests__/files-field.service.copy-file-into-files-field.spec.ts b/packages/twenty-server/src/engine/core-modules/file/files-field/services/__tests__/files-field.service.copy-file-into-files-field.spec.ts
new file mode 100644
index 00000000000..58be9e9efea
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/file/files-field/services/__tests__/files-field.service.copy-file-into-files-field.spec.ts
@@ -0,0 +1,162 @@
+import { type Repository } from 'typeorm';
+
+import { type ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { type FileStorageService } from 'src/engine/core-modules/file-storage/services/file-storage.service';
+import { type FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { type FileUrlService } from 'src/engine/core-modules/file/file-url/file-url.service';
+import { FilesFieldService } from 'src/engine/core-modules/file/files-field/services/files-field.service';
+import { FILE_STATUS } from 'src/engine/core-modules/file/types/file-status.types';
+import { type FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { type WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
+
+describe('FilesFieldService.copyFileIntoFilesField', () => {
+ const workspaceId = '20202020-0000-4000-8000-000000000001';
+ const chatFileId = '20202020-0000-4000-8000-000000000002';
+ const fieldMetadataId = '20202020-0000-4000-8000-000000000004';
+
+ let fileStorageService: jest.Mocked<FileStorageService>;
+ let applicationRepository: jest.Mocked<Repository<ApplicationEntity>>;
+ let fieldMetadataRepository: jest.Mocked<Repository<FieldMetadataEntity>>;
+ let fileRepository: jest.Mocked<WorkspaceScopedRepository<FileEntity>>;
+
+ const buildService = () =>
+ new FilesFieldService(
+ fileStorageService,
+ applicationRepository,
+ fieldMetadataRepository,
+ fileRepository,
+ {} as FileUrlService,
+ );
+
+ const buildChatFile = (overrides: Partial<FileEntity> = {}) =>
+ ({
+ id: chatFileId,
+ path: `agent-chat/${chatFileId}.pdf`,
+ status: FILE_STATUS.UPLOADED,
+ applicationId: 'chat-application-id',
+ mimeType: 'application/pdf',
+ size: 1234,
+ ...overrides,
+ }) as FileEntity;
+
+ beforeEach(() => {
+ fileStorageService = {
+ copy: jest.fn().mockResolvedValue(undefined),
+ } as unknown as jest.Mocked<FileStorageService>;
+
+ applicationRepository = {
+ findOneOrFail: jest.fn().mockImplementation(async ({ where }) => ({
+ universalIdentifier: `${where.id}-universal-identifier`,
+ })),
+ } as unknown as jest.Mocked<Repository<ApplicationEntity>>;
+
+ fieldMetadataRepository = {
+ findOneOrFail: jest.fn().mockResolvedValue({
+ applicationId: 'field-application-id',
+ universalIdentifier: 'field-universal-identifier',
+ }),
+ } as unknown as jest.Mocked<Repository<FieldMetadataEntity>>;
+
+ fileRepository = {
+ findOne: jest.fn().mockResolvedValue(null),
+ insertAndReturnOne: jest
+ .fn()
+ .mockImplementation(async (_workspaceId, entity) => entity),
+ } as unknown as jest.Mocked<WorkspaceScopedRepository<FileEntity>>;
+ });
+
+ afterEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it('should throw when the file does not exist', async () => {
+ await expect(
+ buildService().copyFileIntoFilesField({
+ fileId: chatFileId,
+ workspaceId,
+ fieldMetadataId,
+ }),
+ ).rejects.toThrow(`File ${chatFileId} not found`);
+
+ expect(fileStorageService.copy).not.toHaveBeenCalled();
+ });
+
+ it('should throw when the upload has not been completed', async () => {
+ fileRepository.findOne.mockResolvedValue(
+ buildChatFile({ status: FILE_STATUS.PENDING }),
+ );
+
+ await expect(
+ buildService().copyFileIntoFilesField({
+ fileId: chatFileId,
+ workspaceId,
+ fieldMetadataId,
+ }),
+ ).rejects.toThrow(`File ${chatFileId} upload has not been completed`);
+
+ expect(fileStorageService.copy).not.toHaveBeenCalled();
+ });
+
+ it('should copy an agent-chat file into the files field partition', async () => {
+ fileRepository.findOne.mockResolvedValue(buildChatFile());
+
+ const result = await buildService().copyFileIntoFilesField({
+ fileId: chatFileId,
+ workspaceId,
+ fieldMetadataId,
+ });
+
+ expect(fileStorageService.copy).toHaveBeenCalledTimes(1);
+
+ const copyArgs = fileStorageService.copy.mock.calls[0][0];
+
+ expect(copyArgs.from).toEqual({
+ workspaceId,
+ applicationUniversalIdentifier:
+ 'chat-application-id-universal-identifier',
+ fileFolder: 'agent-chat',
+ resourcePath: `${chatFileId}.pdf`,
+ });
+ expect(copyArgs.to.fileFolder).toBe('files-field');
+ expect(copyArgs.to.applicationUniversalIdentifier).toBe(
+ 'field-application-id-universal-identifier',
+ );
+ expect(copyArgs.to.resourcePath).toMatch(
+ /^field-universal-identifier\/[0-9a-f-]{36}\.pdf$/,
+ );
+
+ expect(fileRepository.insertAndReturnOne).toHaveBeenCalledTimes(1);
+
+ const [insertWorkspaceId, insertedRow] =
+ fileRepository.insertAndReturnOne.mock.calls[0];
+
+ expect(insertWorkspaceId).toBe(workspaceId);
+ expect(insertedRow.path).toBe(`files-field/${copyArgs.to.resourcePath}`);
+ expect(insertedRow.applicationId).toBe('field-application-id');
+ expect(insertedRow.mimeType).toBe('application/pdf');
+ expect(insertedRow.size).toBe(1234);
+ expect(insertedRow.settings).toEqual({
+ isTemporaryFile: true,
+ toDelete: false,
+ });
+
+ expect(insertedRow.id).not.toBe(chatFileId);
+ expect(result.id).toBe(insertedRow.id);
+ });
+
+ it('should keep the source extension when copying', async () => {
+ fileRepository.findOne.mockResolvedValue(
+ buildChatFile({ path: `agent-chat/${chatFileId}.csv` }),
+ );
+
+ await buildService().copyFileIntoFilesField({
+ fileId: chatFileId,
+ workspaceId,
+ fieldMetadataId,
+ });
+
+ expect(fileStorageService.copy.mock.calls[0][0].to.resourcePath).toMatch(
+ /\.csv$/,
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/file/files-field/services/files-field.service.ts b/packages/twenty-server/src/engine/core-modules/file/files-field/services/files-field.service.ts
index fb121493526..148a1a7aaf6 100644
--- a/packages/twenty-server/src/engine/core-modules/file/files-field/services/files-field.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/file/files-field/services/files-field.service.ts
@@ -1,22 +1,30 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
+import { extname } from 'path';
+
import { msg } from '@lingui/core/macro';
import { isNonEmptyString } from '@sniptt/guards';
import { FileFolder } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { Repository } from 'typeorm';
import { v4 } from 'uuid';
import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
import { FileStorageService } from 'src/engine/core-modules/file-storage/services/file-storage.service';
import { FileWithSignedUrlDTO } from 'src/engine/core-modules/file/dtos/file-with-sign-url.dto';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
import { FileUrlService } from 'src/engine/core-modules/file/file-url/file-url.service';
import {
FilesFieldException,
FilesFieldExceptionCode,
} from 'src/engine/core-modules/file/files-field/files-field.exception';
+import { FILE_STATUS } from 'src/engine/core-modules/file/types/file-status.types';
import { extractFileInfoOrThrow } from 'src/engine/core-modules/file/utils/extract-file-info-or-throw.utils';
+import { removeFileFolderFromFileEntityPath } from 'src/engine/core-modules/file/utils/remove-file-folder-from-file-entity-path.utils';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
@Injectable()
export class FilesFieldService {
@@ -26,6 +34,8 @@ export class FilesFieldService {
private readonly applicationRepository: Repository<ApplicationEntity>,
@InjectRepository(FieldMetadataEntity)
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
+ @InjectWorkspaceScopedRepository(FileEntity)
+ private readonly fileRepository: WorkspaceScopedRepository<FileEntity>,
private readonly fileUrlService: FileUrlService,
) {}
@@ -101,6 +111,88 @@ export class FilesFieldService {
};
}
+ async copyFileIntoFilesField({
+ fileId,
+ workspaceId,
+ fieldMetadataId,
+ }: {
+ fileId: string;
+ workspaceId: string;
+ fieldMetadataId: string;
+ }): Promise<FileEntity> {
+ const sourceFile = await this.fileRepository.findOne(workspaceId, {
+ where: { id: fileId },
+ });
+
+ if (!isDefined(sourceFile)) {
+ throw new FilesFieldException(
+ `File ${fileId} not found`,
+ FilesFieldExceptionCode.BAD_REQUEST,
+ { userFriendlyMessage: msg`File not found.` },
+ );
+ }
+
+ if (sourceFile.status !== FILE_STATUS.UPLOADED) {
+ throw new FilesFieldException(
+ `File ${fileId} upload has not been completed`,
+ FilesFieldExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`The file upload has not been completed. Please retry the upload.`,
+ },
+ );
+ }
+
+ const fieldMetadata = await this.fieldMetadataRepository.findOneOrFail({
+ select: ['applicationId', 'universalIdentifier'],
+ where: { id: fieldMetadataId, workspaceId },
+ });
+
+ const [sourceApplication, destinationApplication] = await Promise.all([
+ this.applicationRepository.findOneOrFail({
+ select: ['universalIdentifier'],
+ where: { id: sourceFile.applicationId, workspaceId },
+ }),
+ this.applicationRepository.findOneOrFail({
+ select: ['universalIdentifier'],
+ where: { id: fieldMetadata.applicationId, workspaceId },
+ }),
+ ]);
+
+ const copiedFileId = v4();
+ const extension = extname(sourceFile.path);
+ const resourcePath = `${fieldMetadata.universalIdentifier}/${copiedFileId}${extension}`;
+ const sourceFileFolder = sourceFile.path.split('/')[0] as FileFolder;
+
+ await this.fileStorageService.copy({
+ from: {
+ workspaceId,
+ applicationUniversalIdentifier: sourceApplication.universalIdentifier,
+ fileFolder: sourceFileFolder,
+ resourcePath: removeFileFolderFromFileEntityPath(sourceFile.path),
+ },
+ to: {
+ workspaceId,
+ applicationUniversalIdentifier:
+ destinationApplication.universalIdentifier,
+ fileFolder: FileFolder.FilesField,
+ resourcePath,
+ },
+ });
+
+ return this.fileRepository.insertAndReturnOne(workspaceId, {
+ id: copiedFileId,
+ path: `${FileFolder.FilesField}/${resourcePath}`,
+ applicationId: fieldMetadata.applicationId,
+ mimeType: sourceFile.mimeType,
+ size: sourceFile.size,
+ status: FILE_STATUS.UPLOADED,
+ settings: {
+ isTemporaryFile: true,
+ toDelete: false,
+ },
+ });
+ }
+
async deleteFilesFieldFile({
fileId,
workspaceId,
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/constants/files-field-copyable-source-folders.constant.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/constants/files-field-copyable-source-folders.constant.ts
new file mode 100644
index 00000000000..821ca5695ae
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/constants/files-field-copyable-source-folders.constant.ts
@@ -0,0 +1,5 @@
+import { FileFolder } from 'twenty-shared/types';
+
+export const FILES_FIELD_COPYABLE_SOURCE_FOLDERS: FileFolder[] = [
+ FileFolder.AgentChat,
+];
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/services/record-files-resolver.service.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/services/record-files-resolver.service.ts
new file mode 100644
index 00000000000..9855c6cdcd8
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/services/record-files-resolver.service.ts
@@ -0,0 +1,140 @@
+import { Injectable } from '@nestjs/common';
+
+import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { In } from 'typeorm';
+
+import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FilesFieldService } from 'src/engine/core-modules/file/files-field/services/files-field.service';
+import {
+ collectFileIdsFromFilesFieldValue,
+ substituteFileIdsInFilesFieldValue,
+} from 'src/engine/core-modules/tool-provider/utils/files-field-value-file-ids.util';
+import { isCopyableFilesFieldSourcePath } from 'src/engine/core-modules/tool-provider/utils/is-copyable-files-field-source-path.util';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
+
+export type RecordFilesResolution = {
+ records: Record<string, unknown>[];
+ notes: string[];
+};
+
+@Injectable()
+export class RecordFilesResolverService {
+ constructor(
+ private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ private readonly filesFieldService: FilesFieldService,
+ @InjectWorkspaceScopedRepository(FileEntity)
+ private readonly fileRepository: WorkspaceScopedRepository<FileEntity>,
+ ) {}
+
+ async resolveRecordsInput({
+ objectNameSingular,
+ records,
+ workspaceId,
+ }: {
+ objectNameSingular: string;
+ records: Record<string, unknown>[];
+ workspaceId: string;
+ }): Promise<RecordFilesResolution> {
+ const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
+ await this.workspaceManyOrAllFlatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ {
+ workspaceId,
+ flatMapsKeys: ['flatObjectMetadataMaps', 'flatFieldMetadataMaps'],
+ },
+ );
+
+ const flatObjectMetadata = Object.values(
+ flatObjectMetadataMaps.byUniversalIdentifier,
+ ).find(
+ (metadata): metadata is FlatObjectMetadata =>
+ isDefined(metadata) &&
+ metadata.nameSingular === objectNameSingular &&
+ metadata.isActive,
+ );
+
+ if (!isDefined(flatObjectMetadata)) {
+ return { records, notes: [] };
+ }
+
+ const filesFields = getFlatFieldsFromFlatObjectMetadata(
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ ).filter((field) => field.type === FieldMetadataType.FILES);
+
+ if (filesFields.length === 0) {
+ return { records, notes: [] };
+ }
+
+ const notes: string[] = [];
+ const resolvedRecords: Record<string, unknown>[] = [];
+
+ for (const record of records) {
+ let resolvedRecord = record;
+
+ for (const filesField of filesFields) {
+ const fileIds = collectFileIdsFromFilesFieldValue(
+ resolvedRecord[filesField.name],
+ );
+
+ const copyableFileIds = await this.findCopyableFileIds(
+ fileIds,
+ workspaceId,
+ );
+
+ if (copyableFileIds.length === 0) {
+ continue;
+ }
+
+ const fileIdSubstitutions = new Map<string, string>();
+
+ for (const fileId of copyableFileIds) {
+ const copiedFile =
+ await this.filesFieldService.copyFileIntoFilesField({
+ fileId,
+ workspaceId,
+ fieldMetadataId: filesField.id,
+ });
+
+ fileIdSubstitutions.set(fileId, copiedFile.id);
+ notes.push(
+ `Uploaded file ${fileId} was stored on ${filesField.name} as file ${copiedFile.id}.`,
+ );
+ }
+
+ resolvedRecord = {
+ ...resolvedRecord,
+ [filesField.name]: substituteFileIdsInFilesFieldValue(
+ resolvedRecord[filesField.name],
+ fileIdSubstitutions,
+ ),
+ };
+ }
+
+ resolvedRecords.push(resolvedRecord);
+ }
+
+ return { records: resolvedRecords, notes };
+ }
+
+ private async findCopyableFileIds(
+ fileIds: string[],
+ workspaceId: string,
+ ): Promise<string[]> {
+ if (fileIds.length === 0) {
+ return [];
+ }
+
+ const files = await this.fileRepository.find(workspaceId, {
+ where: { id: In([...new Set(fileIds)]) },
+ });
+
+ return files
+ .filter((file) => isCopyableFilesFieldSourcePath(file.path))
+ .map((file) => file.id);
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-executor.service.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-executor.service.ts
index 6c8b76b1e0d..b44b77112da 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-executor.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-executor.service.ts
@@ -21,6 +21,7 @@ import { UpdateRecordService } from 'src/engine/core-modules/record-crud/service
import { UpsertManyRecordsService } from 'src/engine/core-modules/record-crud/services/upsert-many-records.service';
import { type FindRecordsParams } from 'src/engine/core-modules/record-crud/types/find-records-params.type';
import { TOOL_PROVIDERS } from 'src/engine/core-modules/tool-provider/constants/tool-providers.token';
+import { RecordFilesResolverService } from 'src/engine/core-modules/tool-provider/services/record-files-resolver.service';
import { type ToolProvider } from 'src/engine/core-modules/tool-provider/interfaces/tool-provider.interface';
import { type ToolDescriptor } from 'src/engine/core-modules/tool-provider/types/tool-descriptor.type';
import { type ToolExecutionRef } from 'src/engine/core-modules/tool-provider/types/tool-execution-ref.type';
@@ -49,6 +50,7 @@ export class ToolExecutorService {
private readonly deleteRecordService: DeleteRecordService,
private readonly deleteManyRecordsService: DeleteManyRecordsService,
private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
+ private readonly recordFilesResolverService: RecordFilesResolverService,
private readonly workspaceCacheService: WorkspaceCacheService,
@InjectRepository(UserEntity)
private readonly userRepository: Repository<UserEntity>,
@@ -143,40 +145,69 @@ export class ToolExecutorService {
});
}
- case 'create_one':
- return this.createRecordService.execute({
+ case 'create_one': {
+ const { records, notes } =
+ await this.recordFilesResolverService.resolveRecordsInput({
+ objectNameSingular: ref.objectNameSingular,
+ records: [args],
+ workspaceId: context.workspaceId,
+ });
+
+ const output = await this.createRecordService.execute({
objectName: ref.objectNameSingular,
- objectRecord: args,
+ objectRecord: records[0],
authContext,
rolePermissionConfig: context.rolePermissionConfig,
createdBy: context.actorContext,
slimResponse: true,
});
- case 'create_many':
- return this.createManyRecordsService.execute({
+ return this.appendFileResolutionNotes(output, notes);
+ }
+
+ case 'create_many': {
+ const { records, notes } =
+ await this.recordFilesResolverService.resolveRecordsInput({
+ objectNameSingular: ref.objectNameSingular,
+ records: args.records as Record<string, unknown>[],
+ workspaceId: context.workspaceId,
+ });
+
+ const output = await this.createManyRecordsService.execute({
objectName: ref.objectNameSingular,
- objectRecords: args.records as Record<string, unknown>[],
+ objectRecords: records,
authContext,
rolePermissionConfig: context.rolePermissionConfig,
createdBy: context.actorContext,
slimResponse: true,
});
+ return this.appendFileResolutionNotes(output, notes);
+ }
+
case 'update_one': {
const { id, ...fields } = args;
const objectRecord = Object.fromEntries(
Object.entries(fields).filter(([, value]) => value !== undefined),
);
- return this.updateRecordService.execute({
+ const { records, notes } =
+ await this.recordFilesResolverService.resolveRecordsInput({
+ objectNameSingular: ref.objectNameSingular,
+ records: [objectRecord],
+ workspaceId: context.workspaceId,
+ });
+
+ const output = await this.updateRecordService.execute({
objectName: ref.objectNameSingular,
objectRecordId: id as string,
- objectRecord,
+ objectRecord: records[0],
authContext,
rolePermissionConfig: context.rolePermissionConfig,
slimResponse: true,
});
+
+ return this.appendFileResolutionNotes(output, notes);
}
case 'update_many':
@@ -189,16 +220,26 @@ export class ToolExecutorService {
slimResponse: true,
});
- case 'upsert_many':
- return this.upsertManyRecordsService.execute({
+ case 'upsert_many': {
+ const { records, notes } =
+ await this.recordFilesResolverService.resolveRecordsInput({
+ objectNameSingular: ref.objectNameSingular,
+ records: args.records as Record<string, unknown>[],
+ workspaceId: context.workspaceId,
+ });
+
+ const output = await this.upsertManyRecordsService.execute({
objectName: ref.objectNameSingular,
- objectRecords: args.records as Record<string, unknown>[],
+ objectRecords: records,
authContext,
rolePermissionConfig: context.rolePermissionConfig,
createdBy: context.actorContext,
slimResponse: true,
});
+ return this.appendFileResolutionNotes(output, notes);
+ }
+
case 'delete_one':
return this.deleteRecordService.execute({
objectName: ref.objectNameSingular,
@@ -243,6 +284,20 @@ export class ToolExecutorService {
}
}
+ private appendFileResolutionNotes(
+ output: ToolOutput,
+ notes: string[],
+ ): ToolOutput {
+ if (notes.length === 0) {
+ return output;
+ }
+
+ return {
+ ...output,
+ message: `${output.message} ${notes.join(' ')}`,
+ };
+ }
+
private async dispatchStaticTool(
descriptor: ToolIndexEntry | ToolDescriptor,
args: Record<string, unknown>,
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts
index 0bc08d1e5d4..849049d82e9 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts
@@ -1,6 +1,8 @@
import { forwardRef, Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { FilesFieldModule } from 'src/engine/core-modules/file/files-field/files-field.module';
import { RecordCrudModule } from 'src/engine/core-modules/record-crud/record-crud.module';
import { TOOL_PROVIDERS } from 'src/engine/core-modules/tool-provider/constants/tool-providers.token';
import { ActionToolProvider } from 'src/engine/core-modules/tool-provider/providers/action-tool.provider';
@@ -13,6 +15,7 @@ import { RoleToolProvider } from 'src/engine/core-modules/tool-provider/provider
import { ViewToolProvider } from 'src/engine/core-modules/tool-provider/providers/view-tool.provider';
import { WebhookToolProvider } from 'src/engine/core-modules/tool-provider/providers/webhook-tool.provider';
import { WorkflowToolProvider } from 'src/engine/core-modules/tool-provider/providers/workflow-tool.provider';
+import { RecordFilesResolverService } from 'src/engine/core-modules/tool-provider/services/record-files-resolver.service';
import { ToolExecutorService } from 'src/engine/core-modules/tool-provider/services/tool-executor.service';
import { ToolModule } from 'src/engine/core-modules/tool/tool.module';
import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
@@ -32,6 +35,7 @@ import { ViewFilterModule } from 'src/engine/metadata-modules/view-filter/view-f
import { ViewSortModule } from 'src/engine/metadata-modules/view-sort/view-sort.module';
import { ViewModule } from 'src/engine/metadata-modules/view/view.module';
import { WebhookModule } from 'src/engine/metadata-modules/webhook/webhook.module';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
import { EmailingModule } from 'src/modules/emailing/emailing.module';
@@ -52,6 +56,7 @@ import { ToolRegistryService } from './services/tool-registry.service';
imports: [
ToolModule,
RecordCrudModule,
+ FilesFieldModule,
AiModelsModule,
forwardRef(() => AiAgentExecutionModule),
ObjectMetadataModule,
@@ -69,11 +74,13 @@ import { ToolRegistryService } from './services/tool-registry.service';
RoleModule,
UserRoleModule,
EmailingModule,
- TypeOrmModule.forFeature([UserEntity, UserWorkspaceEntity]),
+ TypeOrmModule.forFeature([UserEntity, UserWorkspaceEntity, FileEntity]),
],
providers: [
ToolIndexResolver,
ToolExecutorService,
+ RecordFilesResolverService,
+ provideWorkspaceScopedRepository(FileEntity),
ActionToolProvider,
DashboardToolProvider,
DatabaseToolProvider,
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/utils/__tests__/files-field-value-file-ids.util.spec.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/__tests__/files-field-value-file-ids.util.spec.ts
new file mode 100644
index 00000000000..cde7026b9cf
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/__tests__/files-field-value-file-ids.util.spec.ts
@@ -0,0 +1,52 @@
+import {
+ collectFileIdsFromFilesFieldValue,
+ substituteFileIdsInFilesFieldValue,
+} from 'src/engine/core-modules/tool-provider/utils/files-field-value-file-ids.util';
+
+describe('collectFileIdsFromFilesFieldValue', () => {
+ it('should collect fileIds from a files field value', () => {
+ expect(
+ collectFileIdsFromFilesFieldValue([
+ { fileId: 'file-1', label: 'a.pdf' },
+ { fileId: 'file-2' },
+ ]),
+ ).toEqual(['file-1', 'file-2']);
+ });
+
+ it('should ignore non-array values and malformed entries', () => {
+ expect(collectFileIdsFromFilesFieldValue(undefined)).toEqual([]);
+ expect(collectFileIdsFromFilesFieldValue('file-1')).toEqual([]);
+ expect(
+ collectFileIdsFromFilesFieldValue([
+ null,
+ 'file-1',
+ { label: 'no-id.pdf' },
+ { fileId: '' },
+ { fileId: 'file-2' },
+ ]),
+ ).toEqual(['file-2']);
+ });
+});
+
+describe('substituteFileIdsInFilesFieldValue', () => {
+ it('should swap substituted fileIds and keep other entry fields', () => {
+ const result = substituteFileIdsInFilesFieldValue(
+ [
+ { fileId: 'chat-file', label: 'contract.pdf' },
+ { fileId: 'already-prepared', label: 'other.pdf' },
+ ],
+ new Map([['chat-file', 'copied-file']]),
+ );
+
+ expect(result).toEqual([
+ { fileId: 'copied-file', label: 'contract.pdf' },
+ { fileId: 'already-prepared', label: 'other.pdf' },
+ ]);
+ });
+
+ it('should return non-array values untouched', () => {
+ expect(substituteFileIdsInFilesFieldValue('not-an-array', new Map())).toBe(
+ 'not-an-array',
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/utils/__tests__/is-copyable-files-field-source-path.util.spec.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/__tests__/is-copyable-files-field-source-path.util.spec.ts
new file mode 100644
index 00000000000..d7267a7f057
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/__tests__/is-copyable-files-field-source-path.util.spec.ts
@@ -0,0 +1,17 @@
+import { isCopyableFilesFieldSourcePath } from 'src/engine/core-modules/tool-provider/utils/is-copyable-files-field-source-path.util';
+
+describe('isCopyableFilesFieldSourcePath', () => {
+ it('should accept agent-chat uploads', () => {
+ expect(isCopyableFilesFieldSourcePath('agent-chat/abc.pdf')).toBe(true);
+ });
+
+ it('should reject files from other folders', () => {
+ expect(
+ isCopyableFilesFieldSourcePath('files-field/field-uid/abc.pdf'),
+ ).toBe(false);
+ expect(isCopyableFilesFieldSourcePath('profile-picture/abc.png')).toBe(
+ false,
+ );
+ expect(isCopyableFilesFieldSourcePath('agent-chat-x/abc.pdf')).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/utils/files-field-value-file-ids.util.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/files-field-value-file-ids.util.ts
new file mode 100644
index 00000000000..cce32df0869
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/files-field-value-file-ids.util.ts
@@ -0,0 +1,32 @@
+import { isNonEmptyString, isObject } from '@sniptt/guards';
+
+type FilesFieldValueEntry = Record<string, unknown> & { fileId: string };
+
+const isFilesFieldValueEntry = (
+ entry: unknown,
+): entry is FilesFieldValueEntry =>
+ isObject(entry) &&
+ isNonEmptyString((entry as Record<string, unknown>).fileId);
+
+export const collectFileIdsFromFilesFieldValue = (value: unknown): string[] => {
+ if (!Array.isArray(value)) {
+ return [];
+ }
+
+ return value.filter(isFilesFieldValueEntry).map((entry) => entry.fileId);
+};
+
+export const substituteFileIdsInFilesFieldValue = (
+ value: unknown,
+ fileIdSubstitutions: Map<string, string>,
+): unknown => {
+ if (!Array.isArray(value)) {
+ return value;
+ }
+
+ return value.map((entry) =>
+ isFilesFieldValueEntry(entry) && fileIdSubstitutions.has(entry.fileId)
+ ? { ...entry, fileId: fileIdSubstitutions.get(entry.fileId) }
+ : entry,
+ );
+};
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/utils/is-copyable-files-field-source-path.util.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/is-copyable-files-field-source-path.util.ts
new file mode 100644
index 00000000000..3cccf1eb1ba
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/utils/is-copyable-files-field-source-path.util.ts
@@ -0,0 +1,6 @@
+import { FILES_FIELD_COPYABLE_SOURCE_FOLDERS } from 'src/engine/core-modules/tool-provider/constants/files-field-copyable-source-folders.constant';
+
+export const isCopyableFilesFieldSourcePath = (path: string): boolean =>
+ FILES_FIELD_COPYABLE_SOURCE_FOLDERS.some((folder) =>
+ path.startsWith(`${folder}/`),
+ );
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/chat-execution.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/chat-execution.service.ts
index 7d949f56b3b..db3538598e5 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/chat-execution.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/chat-execution.service.ts
@@ -72,6 +72,7 @@ import { buildWorkspaceSetupChatThreadId } from 'src/engine/metadata-modules/ai/
import { buildFullSystemPrompt } from 'src/engine/metadata-modules/ai/ai-chat/utils/build-full-system-prompt.util';
import { hasNoAssistantMessage } from 'src/engine/metadata-modules/ai/ai-chat/utils/has-no-assistant-message.util';
import { hasSucceededWorkspaceSetupCompletion } from 'src/engine/metadata-modules/ai/ai-chat/utils/has-succeeded-workspace-setup-completion.util';
+import { collectUploadedFileReferences } from 'src/engine/metadata-modules/ai/ai-chat/utils/collect-uploaded-file-references.util';
import { extractCodeInterpreterFiles } from 'src/engine/metadata-modules/ai/ai-chat/utils/extract-code-interpreter-files.util';
import { injectMessageTimestamps } from 'src/engine/metadata-modules/ai/ai-chat/utils/inject-message-timestamps.util';
import {
@@ -276,6 +277,8 @@ export class ChatExecutionService {
const isCodeInterpreterEnabled = this.codeInterpreterService.isEnabled();
+ const uploadedFiles = collectUploadedFileReferences(messages);
+
let processedMessages: ExtendedUIMessage[] = replaceUnsupportedFileParts(
messages,
modelConfig.modalities,
@@ -321,7 +324,10 @@ export class ChatExecutionService {
toolCatalog,
skillCatalog,
preloadedTools: preloadedToolNames,
- storedFiles,
+ uploadedFilesContext: {
+ uploadedFiles,
+ codeInterpreterFiles: storedFiles,
+ },
workspaceInstructions: workspace.aiAdditionalInstructions ?? undefined,
userContext,
isWorkspaceSetupThread,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/types/uploaded-file-reference.type.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/types/uploaded-file-reference.type.ts
new file mode 100644
index 00000000000..9b976bc1d18
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/types/uploaded-file-reference.type.ts
@@ -0,0 +1,4 @@
+export type UploadedFileReference = {
+ filename: string;
+ fileId: string;
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/__tests__/collect-uploaded-file-references.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/__tests__/collect-uploaded-file-references.util.spec.ts
new file mode 100644
index 00000000000..0bc179ba183
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/__tests__/collect-uploaded-file-references.util.spec.ts
@@ -0,0 +1,67 @@
+import { type ExtendedUIMessage } from 'twenty-shared/ai';
+
+import { collectUploadedFileReferences } from 'src/engine/metadata-modules/ai/ai-chat/utils/collect-uploaded-file-references.util';
+
+describe('collectUploadedFileReferences', () => {
+ const buildFilePart = (fileId: string, filename?: string) => ({
+ type: 'file' as const,
+ mediaType: 'application/pdf',
+ filename,
+ url: 'https://example.com/file',
+ fileId,
+ });
+
+ it('should collect file parts from user messages across the thread', () => {
+ const messages = [
+ {
+ id: '1',
+ role: 'user',
+ parts: [
+ { type: 'text', text: 'here is a file' },
+ buildFilePart('file-1', 'contract.pdf'),
+ ],
+ },
+ {
+ id: '2',
+ role: 'assistant',
+ parts: [{ type: 'text', text: 'thanks' }],
+ },
+ {
+ id: '3',
+ role: 'user',
+ parts: [buildFilePart('file-2', 'data.csv')],
+ },
+ ] as unknown as ExtendedUIMessage[];
+
+ expect(collectUploadedFileReferences(messages)).toEqual([
+ { filename: 'contract.pdf', fileId: 'file-1' },
+ { filename: 'data.csv', fileId: 'file-2' },
+ ]);
+ });
+
+ it('should deduplicate by fileId and default missing filenames', () => {
+ const messages = [
+ {
+ id: '1',
+ role: 'user',
+ parts: [buildFilePart('file-1'), buildFilePart('file-1')],
+ },
+ ] as unknown as ExtendedUIMessage[];
+
+ expect(collectUploadedFileReferences(messages)).toEqual([
+ { filename: 'uploaded_file', fileId: 'file-1' },
+ ]);
+ });
+
+ it('should ignore file parts on assistant messages', () => {
+ const messages = [
+ {
+ id: '1',
+ role: 'assistant',
+ parts: [buildFilePart('file-1', 'generated.pdf')],
+ },
+ ] as unknown as ExtendedUIMessage[];
+
+ expect(collectUploadedFileReferences(messages)).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-full-system-prompt.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-full-system-prompt.util.ts
index eb9baab3f56..d5e68a89513 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-full-system-prompt.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-full-system-prompt.util.ts
@@ -1,5 +1,5 @@
import { isNonEmptyString } from '@sniptt/guards';
-import { isNonEmptyArray } from 'twenty-shared/utils';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
import { type ToolIndexEntry } from 'src/engine/core-modules/tool-provider/types/tool-index-entry.type';
import { buildToolCatalogSection } from 'src/engine/core-modules/tool-provider/utils/build-tool-catalog-section.util';
@@ -10,13 +10,14 @@ import { buildSkillCatalogSection } from 'src/engine/metadata-modules/ai/ai-chat
import { buildUploadedFilesSection } from 'src/engine/metadata-modules/ai/ai-chat/utils/build-uploaded-files-section.util';
import { buildUserContextSection } from 'src/engine/metadata-modules/ai/ai-chat/utils/build-user-context-section.util';
import { buildWorkspaceInstructionsSection } from 'src/engine/metadata-modules/ai/ai-chat/utils/build-workspace-instructions-section.util';
+import { type UploadedFileReference } from 'src/engine/metadata-modules/ai/ai-chat/types/uploaded-file-reference.type';
import { type FlatSkill } from 'src/engine/metadata-modules/flat-skill/types/flat-skill.type';
export const buildFullSystemPrompt = ({
toolCatalog,
skillCatalog,
preloadedTools,
- storedFiles,
+ uploadedFilesContext,
workspaceInstructions,
userContext,
isWorkspaceSetupThread,
@@ -24,10 +25,10 @@ export const buildFullSystemPrompt = ({
toolCatalog: ToolIndexEntry[];
skillCatalog: FlatSkill[];
preloadedTools: string[];
- storedFiles?: Array<{
- filename: string;
- fileId: string;
- }>;
+ uploadedFilesContext?: {
+ uploadedFiles: UploadedFileReference[];
+ codeInterpreterFiles: UploadedFileReference[];
+ };
workspaceInstructions?: string;
userContext?: UserContext;
isWorkspaceSetupThread?: boolean;
@@ -62,8 +63,11 @@ export const buildFullSystemPrompt = ({
parts.push(skillSection);
}
- if (isNonEmptyArray(storedFiles)) {
- parts.push(buildUploadedFilesSection(storedFiles));
+ if (
+ isDefined(uploadedFilesContext) &&
+ isNonEmptyArray(uploadedFilesContext.uploadedFiles)
+ ) {
+ parts.push(buildUploadedFilesSection(uploadedFilesContext));
}
return parts.join('\n');
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-uploaded-files-section.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-uploaded-files-section.util.ts
index 34fd63a14ac..4fe3f9fb38f 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-uploaded-files-section.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/build-uploaded-files-section.util.ts
@@ -1,23 +1,47 @@
-export const buildUploadedFilesSection = (
- storedFiles: Array<{ filename: string; fileId: string }>,
-): string => {
- const fileList = storedFiles.map((f) => `- ${f.filename}`).join('\n');
+import { isNonEmptyArray } from 'twenty-shared/utils';
- const filesJson = JSON.stringify(
- storedFiles.map((f) => ({ filename: f.filename, fileId: f.fileId })),
+import { type UploadedFileReference } from 'src/engine/metadata-modules/ai/ai-chat/types/uploaded-file-reference.type';
+
+export const buildUploadedFilesSection = ({
+ uploadedFiles,
+ codeInterpreterFiles,
+}: {
+ uploadedFiles: UploadedFileReference[];
+ codeInterpreterFiles: UploadedFileReference[];
+}): string => {
+ const uploadedFilesJson = JSON.stringify(
+ uploadedFiles.map((f) => ({ filename: f.filename, fileId: f.fileId })),
);
- return `
+ const sectionParts = [
+ `
## Uploaded Files
-The user has uploaded the following files:
-${fileList}
+The user has uploaded the following files in this conversation:
+\`\`\`json
+${uploadedFilesJson}
+\`\`\`
+
+To store an uploaded file on a record, put it directly in a files-type field value when creating or updating a single record: set the field to an array of \`{ "fileId": "<uploaded fileId>", "label": "<filename>" }\` entries. For example, to attach a document to a person, create an \`attachment\` record with \`file\` set that way and \`targetPersonId\` set. The file is copied automatically and the stored record references the copy's fileId. When updating an existing record, append the new entry to the field's current value: files missing from the new value are detached from the record.`,
+ ];
+
+ if (isNonEmptyArray(codeInterpreterFiles)) {
+ const codeInterpreterFilesJson = JSON.stringify(
+ codeInterpreterFiles.map((f) => ({
+ filename: f.filename,
+ fileId: f.fileId,
+ })),
+ );
-**IMPORTANT**: Use the \`code_interpreter\` tool to analyze these files.
-When calling code_interpreter, include the files parameter with these values (use fileId to reference uploaded files):
+ sectionParts.push(`
+**IMPORTANT**: Use the \`code_interpreter\` tool to analyze these files:
\`\`\`json
-${filesJson}
+${codeInterpreterFilesJson}
\`\`\`
-In your Python code, access files at \`/home/user/{filename}\`.`;
+When calling code_interpreter, include the files parameter with these values (use fileId to reference uploaded files).
+In your Python code, access files at \`/home/user/{filename}\`. Other uploaded files are not available in the sandbox.`);
+ }
+
+ return sectionParts.join('\n');
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/collect-uploaded-file-references.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/collect-uploaded-file-references.util.ts
new file mode 100644
index 00000000000..26b557cc1a9
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/collect-uploaded-file-references.util.ts
@@ -0,0 +1,27 @@
+import { type ExtendedUIMessage, isExtendedFileUIPart } from 'twenty-shared/ai';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type UploadedFileReference } from 'src/engine/metadata-modules/ai/ai-chat/types/uploaded-file-reference.type';
+
+export const collectUploadedFileReferences = (
+ messages: ExtendedUIMessage[],
+): UploadedFileReference[] => {
+ const referencesByFileId = new Map<string, UploadedFileReference>();
+
+ for (const message of messages) {
+ if (message.role !== 'user' || !isDefined(message.parts)) {
+ continue;
+ }
+
+ for (const part of message.parts) {
+ if (isExtendedFileUIPart(part)) {
+ referencesByFileId.set(part.fileId, {
+ filename: part.filename ?? 'uploaded_file',
+ fileId: part.fileId,
+ });
+ }
+ }
+ }
+
+ return [...referencesByFileId.values()];
+};
diff --git a/packages/twenty-server/test/integration/ai/suites/record-files-resolver.integration-spec.ts b/packages/twenty-server/test/integration/ai/suites/record-files-resolver.integration-spec.ts
new file mode 100644
index 00000000000..2d1e56ba191
--- /dev/null
+++ b/packages/twenty-server/test/integration/ai/suites/record-files-resolver.integration-spec.ts
@@ -0,0 +1,143 @@
+import { randomUUID } from 'node:crypto';
+
+import gql from 'graphql-tag';
+import request from 'supertest';
+import { makeMetadataAPIRequestWithFileUpload } from 'test/integration/metadata/suites/utils/make-metadata-api-request-with-file-upload.util';
+import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
+
+const TEST_WORKSPACE_SCHEMA = 'workspace_1wgvd1injqtife6y4rvfbu3h5';
+
+const uploadAiChatFileMutation = gql`
+ mutation UploadAiChatFile($file: Upload!) {
+ uploadAiChatFile(file: $file) {
+ id
+ path
+ }
+ }
+`;
+
+type McpToolCallResult = {
+ content?: Array<{ type: string; text: string }>;
+ isError?: boolean;
+};
+
+type DatabaseToolPayload<TResult> = {
+ success: boolean;
+ message: string;
+ result: TResult;
+};
+
+const callExecuteTool = async <TResult>(
+ toolName: string,
+ args: Record<string, unknown>,
+): Promise<DatabaseToolPayload<TResult>> => {
+ const id = `call-${randomUUID()}`;
+
+ const res = await request(`http://localhost:${APP_PORT}`)
+ .post('/mcp')
+ .set('Authorization', `Bearer ${API_KEY_ACCESS_TOKEN}`)
+ .set('Content-Type', 'application/json')
+ .set('Accept', 'application/json')
+ .send(
+ JSON.stringify({
+ jsonrpc: '2.0',
+ method: 'tools/call',
+ id,
+ params: {
+ name: 'execute_tool',
+ arguments: { toolName, arguments: args },
+ },
+ }),
+ )
+ .expect(200);
+
+ const result = res.body.result as McpToolCallResult;
+
+ expect(result.isError).toBe(false);
+
+ return JSON.parse(
+ result.content?.[0]?.text as string,
+ ) as DatabaseToolPayload<TResult>;
+};
+
+const getAttachmentFileIds = async (
+ attachmentIds: string[],
+): Promise<string[]> => {
+ const rows = await global.testDataSource.query(
+ `SELECT id, file FROM "${TEST_WORKSPACE_SCHEMA}"."attachment" WHERE id = ANY($1)`,
+ [attachmentIds],
+ );
+
+ return rows.map(
+ (row: { file: Array<{ fileId: string }> }) => row.file[0].fileId,
+ );
+};
+
+describe('agent chat files in record CRUD tools (integration)', () => {
+ let chatFileId: string;
+ const createdAttachmentIds: string[] = [];
+
+ beforeAll(async () => {
+ jest.useRealTimers();
+
+ const response = await makeMetadataAPIRequestWithFileUpload(
+ { query: uploadAiChatFileMutation, variables: { file: null } },
+ {
+ field: 'file',
+ buffer: Buffer.from('%PDF-1.4 chat upload'),
+ filename: 'chat-upload.pdf',
+ contentType: 'application/pdf',
+ },
+ );
+
+ chatFileId = response.body.data.uploadAiChatFile.id;
+
+ expect(response.body.data.uploadAiChatFile.path).toContain('agent-chat/');
+ });
+
+ afterAll(async () => {
+ await deleteRecordsByIds('attachment', createdAttachmentIds);
+ });
+
+ it('should copy a chat upload once per record when several records reference it', async () => {
+ const payload = await callExecuteTool<Array<{ id: string }>>(
+ 'create_many_attachments',
+ {
+ records: [
+ {
+ name: 'first.pdf',
+ file: [{ fileId: chatFileId, label: 'first.pdf' }],
+ },
+ {
+ name: 'second.pdf',
+ file: [{ fileId: chatFileId, label: 'second.pdf' }],
+ },
+ ],
+ },
+ );
+
+ expect(payload.success).toBe(true);
+
+ const attachmentIds = payload.result.map((record) => record.id);
+
+ createdAttachmentIds.push(...attachmentIds);
+
+ expect(attachmentIds).toHaveLength(2);
+
+ const storedFileIds = await getAttachmentFileIds(attachmentIds);
+
+ expect(storedFileIds).toHaveLength(2);
+ expect(storedFileIds[0]).not.toBe(storedFileIds[1]);
+ expect(storedFileIds).not.toContain(chatFileId);
+
+ const copiedFiles = await global.testDataSource.query(
+ 'SELECT id, path FROM core."file" WHERE id = ANY($1)',
+ [storedFileIds],
+ );
+
+ expect(copiedFiles).toHaveLength(2);
+ copiedFiles.forEach((file: { path: string }) => {
+ expect(file.path).toContain('files-field/');
+ });
+ });
+});