The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(ai): make the member a keyed runAgent call acts as the owner of the thread it continues (#28193)
Abdul Rahman9e30e158ca2e
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.tsindex c1b302bf538..9dc52d5d2bb 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.ts@@ -30,7 +30,10 @@ import { ApplicationLookupService } from 'src/engine/core-modules/application/apimport { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';import { workspaceAuthContextStorage } from 'src/engine/core-modules/auth/storage/workspace-auth-context.storage';-import { type ApplicationWorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';+import {+ type ApplicationWorkspaceAuthContext,+ type UserWorkspaceAuthContext,+} from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { buildApiKeyAuthContext } from 'src/engine/core-modules/auth/utils/build-api-key-auth-context.util';import { UsageOperationType } from 'src/engine/core-modules/usage/enums/usage-operation-type.enum';import { type FlatWorkspace } from 'src/engine/core-modules/workspace/types/flat-workspace.type';@@ -57,6 +60,7 @@ import { buildAgentRunThreadId } from 'src/engine/metadata-modules/ai/ai-agent-eimport { resolveRunAgentMessagesOrThrow } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/resolve-run-agent-messages-or-throw.util';import { AGENT_RUN_BASE_SYSTEM_PROMPT } from 'src/engine/metadata-modules/ai/ai-agent/constants/agent-run-base-system-prompt.const';import { AgentEntity } from 'src/engine/metadata-modules/ai/ai-agent/entities/agent.entity';+import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';import {AiException,AiExceptionCode,@@ -103,6 +107,7 @@ export class AgentRunService implements AgentRunCallerHandler, OnModuleInit {constructor(private readonly agentActorContextService: AgentActorContextService,private readonly agentRunnerService: AgentRunnerService,+ private readonly agentChatThreadService: AgentChatThreadService,private readonly agentRunSettlementService: AgentRunSettlementService,private readonly agentRunSuspensionService: AgentRunSuspensionService,private readonly callerHandlerRegistry: AgentRunCallerHandlerRegistryService,@@ -261,6 +266,19 @@ export class AgentRunService implements AgentRunCallerHandler, OnModuleInit {responseFormat ?? agent.responseFormat,);+ const title = isNonEmptyString(thread?.title) ? thread.title : agent.label;++ if (+ isContinuingConversation &&+ isUserAuthContext(executionContext.authContext)+ ) {+ await this.claimThreadForMember({+ threadId,+ authContext: executionContext.authContext,+ title,+ });+ }+const runId = randomUUID();await this.agentRunnerService.start({@@ -272,7 +290,7 @@ export class AgentRunService implements AgentRunCallerHandler, OnModuleInit {},spec: {agentId: agent.id,- title: isNonEmptyString(thread?.title) ? thread.title : agent.label,+ title,baseSystemPrompt: AGENT_RUN_BASE_SYSTEM_PROMPT,// kept with the run rather than in its messages, so a run that waits still has them when it goes oninstructions: input.additionalInstructions ?? null,@@ -305,6 +323,33 @@ export class AgentRunService implements AgentRunCallerHandler, OnModuleInit {});}+ private async claimThreadForMember({+ threadId,+ authContext,+ title,+ }: {+ threadId: string;+ authContext: Pick<+ UserWorkspaceAuthContext,+ 'workspace' | 'workspaceMemberId'+ >;+ title: string;+ }): Promise<void> {+ try {+ await this.agentChatThreadService.claimThreadForRun({+ threadId,+ workspaceId: authContext.workspace.id,+ workspaceMemberId: authContext.workspaceMemberId,+ title,+ });+ } catch (error) {+ this.logger.warn(+ `Could not claim thread ${threadId} of workspace ${authContext.workspace.id} for member ${authContext.workspaceMemberId}`,+ error,+ );+ }+ }+// a call that waits on the run gets how it settled; a run that goes on later lands in its conversationasync onSuspended({ caller }: AgentRunCallerInput): Promise<void> {await this.publishSettledRun({diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.tsindex 1b83c28a088..c1158a12f0c 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.ts@@ -78,7 +78,7 @@ const buildResolver = () => {);const chatService = new AgentChatService(threadRepository as never,- {} as never,+ { find: jest.fn().mockResolvedValue([]) } as never,messages as never,{} as never,sharing as never,@@ -182,7 +182,7 @@ describe('Shared conversation API boundaries', () => {new Error('restore failed'),);await expect(- context.chatService.restoreThread({+ context.threadService.restoreThread({threadId: THREAD_ID,workspaceMemberId: 'owner',workspaceId: WORKSPACE_ID,@@ -315,7 +315,7 @@ describe('Shared conversation API boundaries', () => {workspace,),restore: () =>- context.chatService.restoreThread({+ context.threadService.restoreThread({threadId: THREAD_ID,workspaceMemberId: VIEWER_ID,workspaceId: WORKSPACE_ID,diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.tsindex 78717516d27..17039787183 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.ts@@ -299,7 +299,7 @@ export class AgentChatResolver {}if (isDefined(thread.deletedAt)) {- await this.agentChatService.restoreThread({+ await this.threadService.restoreThread({threadId,workspaceMemberId,workspaceId: workspace.id,diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.tsindex 22b7d0b18af..c111b96d080 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.ts@@ -12,6 +12,7 @@ import { PermissionFlagType } from 'twenty-shared/constants';import { RecordShareAccessLevel } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';+import { type UserWorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { buildRecordShareLockKey } from 'src/engine/core-modules/record-share/utils/build-record-share-lock-key.util';import { RecordShareException } from 'src/engine/core-modules/record-share/record-share.exception';import { RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';@@ -22,6 +23,7 @@ import { acquireAgentChatChannelGrantLocksForThreadWriteOrThrow } from 'src/engiimport { findAgentChatFlatObjectMetadata } from 'src/engine/metadata-modules/ai/ai-chat/utils/find-agent-chat-flat-object-metadata.util';import { lockAgentChatChannelForThreadWriteOrThrow } from 'src/engine/metadata-modules/ai/ai-chat/utils/lock-agent-chat-channel-for-thread-write-or-throw.util';import { throwAgentChatThreadNotFound } from 'src/engine/metadata-modules/ai/ai-chat/utils/throw-agent-chat-thread-not-found.util';+import { AgentMessageRole } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-role.enum';import { AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';import { InjectAgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/inject-agent-history-repository.decorator';import { AgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/agent-history-repository';@@ -214,6 +216,7 @@ export class AgentChatSharingService {title?: string;// filed under done for its owner, until activity brings it back to their inboxisArchived?: boolean;+ isSubscribed?: boolean;// checked by the caller, as the member must be able to reach itchannelId?: string;}): Promise<AgentChatThreadWorkspaceEntity> {@@ -222,17 +225,10 @@ export class AgentChatSharingService {const participantObjectMetadataId =await this.getParticipantObjectMetadataId(args.workspaceId);- await this.workspaceOrmManager.executeInWorkspaceContext(- () =>- this.workspaceOrmManager- .getRepositoryWithContextPermissions('agentChatThread')- .validateWriteIsPermitted({- operationType: 'insert',- columnsToReturn: ['id'],- updatedColumns: isDefined(args.title) ? ['title'] : [],- }),+ await this.validateThreadCreationIsPermitted({authContext,- );+ updatedColumns: isDefined(args.title) ? ['title'] : [],+ });return this.threadRepository.query(args.workspaceId,@@ -294,12 +290,111 @@ export class AgentChatSharingService {threadIds: [record.id],participantObjectMetadataId,isArchived: args.isArchived,+ isSubscribed: args.isSubscribed,});return setUpRecord ?? record;},);}+ private validateThreadCreationIsPermitted({+ authContext,+ updatedColumns,+ }: {+ authContext: UserWorkspaceAuthContext;+ updatedColumns: string[];+ }): Promise<void> {+ return this.workspaceOrmManager.executeInWorkspaceContext(+ () =>+ this.workspaceOrmManager+ .getRepositoryWithContextPermissions('agentChatThread')+ .validateWriteIsPermitted({+ operationType: 'insert',+ columnsToReturn: ['id'],+ updatedColumns,+ }),+ authContext,+ );+ }++ async claimUnownedThreadForRun(+ args: AgentChatThreadAccessArgs,+ ): Promise<AgentChatThreadWorkspaceEntity | null> {+ const authContext = await this.getAuthContext(args);++ await this.validateThreadCreationIsPermitted({+ authContext,+ updatedColumns: [],+ });++ const participantObjectMetadataId =+ await this.getParticipantObjectMetadataId(args.workspaceId);++ return this.threadRepository.query(+ args.workspaceId,+ async ({ manager, table }) => {+ const [thread] = await manager.query<AgentChatThreadWorkspaceEntity[]>(+ `WITH claimed_thread AS (+ UPDATE ${table('agentChatThread')}+ SET "workspaceMemberId" = $2,+ "lastActivityAt" = COALESCE("lastActivityAt", clock_timestamp())+ WHERE id = $1+ AND "workspaceMemberId" IS NULL+ AND NOT EXISTS (+ SELECT 1 FROM ${table('agentMessage')}+ WHERE "threadId" = $1+ AND role = $3+ AND "senderWorkspaceMemberId" IS DISTINCT FROM $2+ )+ RETURNING *+ )+ SELECT * FROM claimed_thread`,+ [args.threadId, authContext.workspaceMemberId, AgentMessageRole.USER],+ );++ if (!isDefined(thread)) {+ return null;+ }++ const ownerGrantCount = await backfillWorkspaceChatThreadOwnerGrants({+ manager,+ workspaceId: args.workspaceId,+ threadTableExpression: table('agentChatThread'),+ recordIds: [thread.id],+ });++ if (ownerGrantCount !== 1) {+ throw new AiException(+ 'Thread owner is no longer a workspace member',+ AiExceptionCode.THREAD_NOT_FOUND,+ );+ }+ await manager.query(+ `WITH participant AS (+ INSERT INTO ${getAgentChatThreadParticipantTable(args.workspaceId)} ("threadId", "workspaceMemberId", "lastReadAt", "isSubscribed")+ VALUES ($1, $2, clock_timestamp(), false)+ ON CONFLICT ("threadId", "workspaceMemberId") DO NOTHING+ RETURNING id, "workspaceMemberId"+ ), owner_share AS (+ ${buildAgentChatThreadParticipantOwnerShareInsert({+ workspaceId: args.workspaceId,+ participantSource: 'participant',+ objectMetadataIdParameter: '$3',+ })}+ )+ SELECT * FROM participant`,+ [+ thread.id,+ authContext.workspaceMemberId,+ participantObjectMetadataId,+ ],+ );++ return thread;+ },+ );+ }+// A new thread sorts by its creation and starts read in its creator's// inbox. Threads already set up keep their state, so an upsert of an// existing thread through the record API cannot reset it.@@ -311,12 +406,14 @@ export class AgentChatSharingService {threadIds,participantObjectMetadataId,isArchived = false,+ isSubscribed = true,}: AgentHistoryStorageContext & {workspaceId: string;workspaceMemberId: string;threadIds: string[];participantObjectMetadataId: string;isArchived?: boolean;+ isSubscribed?: boolean;}): Promise<AgentChatThreadWorkspaceEntity[]> {return manager.query<AgentChatThreadWorkspaceEntity[]>(`WITH thread AS (@@ -325,8 +422,8 @@ export class AgentChatSharingService {WHERE id = ANY($1::uuid[]) AND "lastActivityAt" IS NULLRETURNING *), participant AS (- INSERT INTO ${getAgentChatThreadParticipantTable(workspaceId)} ("threadId", "workspaceMemberId", "lastReadAt", "archivedAt")- SELECT thread.id, $2, thread."lastActivityAt", CASE WHEN $4::boolean THEN clock_timestamp() END+ INSERT INTO ${getAgentChatThreadParticipantTable(workspaceId)} ("threadId", "workspaceMemberId", "lastReadAt", "archivedAt", "isSubscribed")+ SELECT thread.id, $2, thread."lastActivityAt", CASE WHEN $4::boolean THEN clock_timestamp() END, $5::booleanFROM threadON CONFLICT ("threadId", "workspaceMemberId") DO NOTHINGRETURNING id, "workspaceMemberId"@@ -338,7 +435,13 @@ export class AgentChatSharingService {})})SELECT * FROM thread`,- [threadIds, workspaceMemberId, participantObjectMetadataId, isArchived],+ [+ threadIds,+ workspaceMemberId,+ participantObjectMetadataId,+ isArchived,+ isSubscribed,+ ],);}diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service.tsindex 740aa7d5bc3..900128cb653 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service.ts@@ -3,6 +3,7 @@ import { Injectable, Logger } from '@nestjs/common';import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';import { In, IsNull } from 'typeorm';+import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { AGENT_CHAT_THREAD_ACTIVITY_COLUMNS } from 'src/engine/metadata-modules/ai/ai-chat/constants/agent-chat-thread-activity-columns.constant';@@ -72,23 +73,120 @@ export class AgentChatThreadService {// An existing thread is left for the caller to check access to.async createThreadIfMissing({threadId,+ title,+ isSubscribed,...args- }: AgentChatThreadAccessArgs & { channelId?: string }): Promise<void> {+ }: AgentChatThreadAccessArgs & {+ title?: string;+ isSubscribed?: boolean;+ channelId?: string;+ }): Promise<boolean> {if (await this.threadRepository.existsBy(args.workspaceId, { id: threadId })) {- return;+ return false;}try {- await this.createThread({ ...args, id: threadId });+ await this.createThread({ ...args, id: threadId, title, isSubscribed });} catch (error) {if (!isUniqueViolationError(error)) {throw error;}++ return false;+ }++ return true;+ }++ async claimThreadForRun({+ title,+ ...args+ }: AgentChatThreadAccessArgs & { title: string }): Promise<void> {+ const threadBefore = await this.findThread(args);++ if (isDefined(threadBefore)) {+ return this.claimExistingThread({ args, threadBefore });+ }++ if (+ await this.createThreadIfMissing({ ...args, title, isSubscribed: false })+ ) {+ return;+ }++ const threadCreatedMeanwhile = await this.findThread(args);++ if (isDefined(threadCreatedMeanwhile)) {+ await this.claimExistingThread({+ args,+ threadBefore: threadCreatedMeanwhile,+ });}}+ private findThread(+ args: Pick<AgentChatThreadAccessArgs, 'workspaceId' | 'threadId'>,+ ): Promise<AgentChatThreadWorkspaceEntity | null> {+ return this.threadRepository.findOne(args.workspaceId, {+ where: { id: args.threadId },+ });+ }++ private async claimExistingThread({+ args,+ threadBefore,+ }: {+ args: AgentChatThreadAccessArgs;+ threadBefore: AgentChatThreadWorkspaceEntity;+ }): Promise<void> {+ if (!isDefined(threadBefore.workspaceMemberId)) {+ const claimedThread =+ await this.sharingService.claimUnownedThreadForRun(args);++ if (isDefined(claimedThread)) {+ await this.participantService.emitParticipantCreated(args);+ await this.threadRecordEventService.emitThreadUpdated({+ workspaceId: args.workspaceId,+ threadBefore,+ });+ }+ }++ if (isDefined(threadBefore.deletedAt)) {+ await this.restoreDeletedThread({ args, threadBefore });+ }+ }++ async restoreThread(+ args: AgentChatThreadAccessArgs,+ ): Promise<AgentChatThreadWorkspaceEntity> {+ const threadBefore = await this.findThread(args);++ return this.restoreDeletedThread({ args, threadBefore });+ }++ private async restoreDeletedThread({+ args,+ threadBefore,+ }: {+ args: AgentChatThreadAccessArgs;+ threadBefore: AgentChatThreadWorkspaceEntity | null;+ }): Promise<AgentChatThreadWorkspaceEntity> {+ const thread = await this.sharingService.restoreThreadWithAccess(args);++ if (isDefined(threadBefore)) {+ await this.threadRecordEventService.emitThreadUpdated({+ workspaceId: args.workspaceId,+ threadBefore,+ action: DatabaseEventAction.RESTORED,+ });+ }++ return thread;+ }+// owned threads are skipped so an upsert cannot reassign themasync assignCreatedThreadsToCreator({authContext,diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.tsindex aa08b1f4f72..a116430461a 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.ts@@ -21,11 +21,11 @@ import { buildActorMetadataFromAuthContext } from 'src/engine/core-modules/actorimport { AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity';import { AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';import { AgentChatThreadRecordEventService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-record-event.service';+import { filterPartsOfTurnActedByOthers } from 'src/engine/metadata-modules/ai/ai-history/utils/filter-parts-of-turn-acted-by-others.util';import { resolveMessageSenderApplicationId } from 'src/engine/metadata-modules/ai/ai-chat/utils/resolve-message-sender-application-id.util';import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';import { AgentConversationWriterService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service';import { AgentTitleGenerationService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-title-generation.service';-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';@Injectable()export class AgentChatService {@@ -247,44 +247,43 @@ export class AgentChatService {});// contexts are given to the model, never shown- return this.messageRepository.find(workspaceId, {- where: {- threadId,- role: Not(AgentMessageRole.SYSTEM),- },- order: { processedAt: { order: 'ASC', nulls: 'NULLS LAST' } },- relations: ['parts', 'parts.file'],- });- }+ const [messages, turns] = await Promise.all([+ this.messageRepository.find(workspaceId, {+ where: {+ threadId,+ role: Not(AgentMessageRole.SYSTEM),+ },+ order: { processedAt: { order: 'ASC', nulls: 'NULLS LAST' } },+ relations: ['parts', 'parts.file'],+ }),+ this.turnRepository.find(workspaceId, { where: { threadId } }),+ ]);+ // the opener is stamped on the turn, so a run resumed in a new turn after a pause is still theirs+ const turnIdsOpenedByOtherMembers = new Set(+ turns+ .filter(+ ({ createdBy }) =>+ isDefined(createdBy.workspaceMemberId) &&+ createdBy.workspaceMemberId !== workspaceMemberId,+ )+ .map(({ id }) => id),+ );- async restoreThread({- threadId,- workspaceMemberId,- workspaceId,- }: {- threadId: string;- workspaceMemberId: string;- workspaceId: string;- }): Promise<AgentChatThreadWorkspaceEntity> {- // Access-checked writes return raw rows; record events carry ORM records- const threadBefore = await this.threadRepository.findOne(workspaceId, {- where: { id: threadId },- });- const thread = await this.sharingService.restoreThreadWithAccess({- threadId,- workspaceMemberId,- workspaceId,+ // their message and attachments are theirs to show; only the reply ran under their permissions+ return messages.map((message) => {+ if (+ !isDefined(message.turnId) ||+ !turnIdsOpenedByOtherMembers.has(message.turnId) ||+ message.role === AgentMessageRole.USER+ ) {+ return message;+ }++ return {+ ...message,+ parts: filterPartsOfTurnActedByOthers(message.parts ?? []),+ };});-- if (isDefined(threadBefore)) {- await this.threadRecordEventService.emitThreadUpdated({- workspaceId,- threadBefore,- action: DatabaseEventAction.RESTORED,- });- }-- return thread;}async notifyThreadUsageUpdated({diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/workspace-setup-chat.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/workspace-setup-chat.service.tsindex 0cb21221098..58abb1f86eb 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/workspace-setup-chat.service.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/workspace-setup-chat.service.ts@@ -118,7 +118,7 @@ export class WorkspaceSetupChatService {if (isDefined(thread)) {if (isDefined(thread.deletedAt)) {- thread = await this.agentChatService.restoreThread({+ thread = await this.threadService.restoreThread({threadId,workspaceMemberId,workspaceId: workspace.id,diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.tsindex efbd5a40c3d..1522e675deb 100644--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.ts+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.ts@@ -20,6 +20,7 @@ import { type AgentMessagePartWorkspaceEntity } from 'src/engine/metadata-moduleimport { type AgentMessageWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message.workspace-entity';import { type AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity';import { type AgentConversationActor } from 'src/engine/metadata-modules/ai/ai-history/types/agent-conversation-actor.type';+import { filterPartsOfTurnActedByOthers } from 'src/engine/metadata-modules/ai/ai-history/utils/filter-parts-of-turn-acted-by-others.util';import { findTurnIdsActedByOthers } from 'src/engine/metadata-modules/ai/ai-history/utils/find-turn-ids-acted-by-others.util';@Injectable()@@ -118,7 +119,7 @@ export class AgentConversationReaderService {id: message.id,role: message.role as ExtendedUIMessage['role'],parts: isActedByOthers- ? parts.filter((part) => part.type === 'text')+ ? filterPartsOfTurnActedByOthers(parts): await this.signFileParts({ workspaceId, parts }),};}),diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/filter-parts-of-turn-acted-by-others.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/filter-parts-of-turn-acted-by-others.util.tsnew file mode 100644index 00000000000..5aedc408009--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/filter-parts-of-turn-acted-by-others.util.ts@@ -0,0 +1,3 @@+export const filterPartsOfTurnActedByOthers = <TPart extends { type: string }>(+ parts: TPart[],+): TPart[] => parts.filter(({ type }) => type === 'text');diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.tsindex 9d761053a64..df5e73c89f6 100644--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts@@ -554,8 +554,6 @@ describe('Conversation sharing through the authenticated API', () => {const cache = getAppProviderByClassName<WorkspaceCacheService>('WorkspaceCacheService',);- const chatService =- getAppProviderByClassName<AgentChatService>('AgentChatService');const command = new EnableCommonRecordSharingCommand({} as never,cache,@@ -610,8 +608,8 @@ describe('Conversation sharing through the authenticated API', () => {);expect((await readThread(owner.threadId)).body.errors).toBeUndefined();const restoredTwice = await Promise.all([- chatService.restoreThread(owner),- chatService.restoreThread(owner),+ getAgentChatThreadService().restoreThread(owner),+ getAgentChatThreadService().restoreThread(owner),]);for (const restored of restoredTwice) {expect(restored.deletedAt).toBeNull();diff --git a/packages/twenty-server/test/integration/graphql/suites/user-session/successful-agent-run-conversation-for-caller.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/user-session/successful-agent-run-conversation-for-caller.integration-spec.tsindex 0015ee00513..b121d39700d 100644--- a/packages/twenty-server/test/integration/graphql/suites/user-session/successful-agent-run-conversation-for-caller.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/user-session/successful-agent-run-conversation-for-caller.integration-spec.ts@@ -1,10 +1,12 @@import { type StepResult, type ToolSet } from 'ai';import { randomUUID } from 'node:crypto';+import { parse } from 'graphql';import {type AgentRunExecution,captureAgentRunExecution,} from 'test/integration/graphql/suites/user-session/utils/capture-agent-run-execution.util';import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';+import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';import {type ApplicationWithResources,setupApplicationWithResources,@@ -111,6 +113,67 @@ const findRecordedTurn = async (threadId: string) => {return { ...message, ...turn };};+const findThread = async (threadId: string) => {+ const [thread] = await globalThis.testDataSource.query(+ `SELECT "workspaceMemberId", "deletedAt"+ FROM "${WORKSPACE_SCHEMA}"."agentChatThread"+ WHERE id = $1`,+ [threadId],+ );++ return thread;+};++const findThreadOwner = async (threadId: string) =>+ (await findThread(threadId)).workspaceMemberId;++const isThreadFollowed = async ({+ threadId,+ workspaceMemberId,+}: {+ threadId: string;+ workspaceMemberId: string;+}) => {+ const [participant] = await globalThis.testDataSource.query(+ `SELECT "isSubscribed" FROM "${WORKSPACE_SCHEMA}"."agentChatThreadParticipant"+ WHERE "threadId" = $1 AND "workspaceMemberId" = $2`,+ [threadId, workspaceMemberId],+ );++ return participant?.isSubscribed ?? null;+};++const countThreadOwnerGrants = async ({+ threadId,+ workspaceMemberId,+}: {+ threadId: string;+ workspaceMemberId: string;+}) => {+ const [{ count }] = await globalThis.testDataSource.query(+ `SELECT count(*)::int AS count FROM "${WORKSPACE_SCHEMA}"."recordShare"+ WHERE "recordId" = $1 AND "principalId" = $2 AND "rowCause" = 'OWNER'`,+ [threadId, workspaceMemberId],+ );++ return count;+};++const disownThread = async (threadId: string) => {+ await globalThis.testDataSource.query(+ `DELETE FROM "${WORKSPACE_SCHEMA}"."recordShare" WHERE "recordId" = $1`,+ [threadId],+ );+ await globalThis.testDataSource.query(+ `DELETE FROM "${WORKSPACE_SCHEMA}"."agentChatThreadParticipant" WHERE "threadId" = $1`,+ [threadId],+ );+ await globalThis.testDataSource.query(+ `UPDATE "${WORKSPACE_SCHEMA}"."agentChatThread" SET "workspaceMemberId" = NULL WHERE id = $1`,+ [threadId],+ );+};+const findPriorMessagePartTypes = ({ priorMessages }: AgentRunExecution) =>(priorMessages ?? []).flatMap(({ parts }) => parts.map(({ type }) => type));@@ -122,16 +185,19 @@ describe('Agent run conversation should be recorded for the caller', () => {const runAgent = async ({token,threadKey,+ runAsWorkspaceMemberId,steps,}: {token: string;threadKey?: string;+ runAsWorkspaceMemberId?: string;steps?: StepResult<ToolSet>[];}) => {const execution = await captureAgentRunExecution({agentUniversalIdentifier: globalTestContext.agentUniversalIdentifier,token,thread: isDefined(threadKey) ? { key: threadKey } : undefined,+ runAsWorkspaceMemberId,steps,});@@ -180,7 +246,11 @@ describe('Agent run conversation should be recorded for the caller', () => {}, 120000);afterAll(async () => {- // no member is granted the threads runAgent creates, so the API cannot destroy them+ // the application's own threads have no member who could destroy them through the API+ await globalThis.testDataSource.query(+ `DELETE FROM "${WORKSPACE_SCHEMA}"."recordShare" WHERE "recordId" = ANY($1)`,+ [threadIds],+ );await globalThis.testDataSource.query(`DELETE FROM "${WORKSPACE_SCHEMA}"."agentChatThread" WHERE id = ANY($1)`,[threadIds],@@ -227,6 +297,104 @@ describe('Agent run conversation should be recorded for the caller', () => {});expect(findPriorMessagePartTypes(execution)).toContain('tool-probe');+ expect(await findThreadOwner(execution.threadId)).toBe(+ WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,+ );+ });++ it('should give the thread to the member the application runs it as', async () => {+ const { threadId } = await runAgent({+ token: globalTestContext.applicationToken,+ threadKey: randomUUID(),+ runAsWorkspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ });++ expect(await findThreadOwner(threadId)).toBe(+ WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ );+ expect(+ await isThreadFollowed({+ threadId,+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ }),+ ).toBe(false);+ });++ it('should give a thread left without an owner to the member who took part in it', async () => {+ const threadKey = randomUUID();+ const runAsJony = () =>+ runAgent({+ token: globalTestContext.applicationToken,+ threadKey,+ runAsWorkspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ });+ const { threadId } = await runAsJony();++ await disownThread(threadId);++ await runAsJony();++ expect(await findThreadOwner(threadId)).toBe(+ WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ );+ expect(+ await countThreadOwnerGrants({+ threadId,+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ }),+ ).toBe(1);+ expect(+ await isThreadFollowed({+ threadId,+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ }),+ ).toBe(false);+ });++ it('should not give a member a thread someone else took part in', async () => {+ const threadKey = randomUUID();++ await runAgent({+ token: globalTestContext.applicationToken,+ threadKey,+ });++ const { threadId } = await runAgent({+ token: globalTestContext.applicationToken,+ threadKey,+ runAsWorkspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ });++ expect(await findThreadOwner(threadId)).toBeNull();+ expect(+ await countThreadOwnerGrants({+ threadId,+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ }),+ ).toBe(0);+ });++ it('should bring back a thread its owner deleted when they run it again', async () => {+ const threadKey = randomUUID();+ const runAsJony = () =>+ runAgent({+ token: globalTestContext.applicationToken,+ threadKey,+ runAsWorkspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ });+ const { threadId } = await runAsJony();++ await globalThis.testDataSource.query(+ `UPDATE "${WORKSPACE_SCHEMA}"."agentChatThread" SET "deletedAt" = NOW() WHERE id = $1`,+ [threadId],+ );++ await runAsJony();++ expect(await findThread(threadId)).toEqual({+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ deletedAt: null,+ });});it('should show a member only the text of a turn another member sent in the same thread', async () => {@@ -253,4 +421,50 @@ describe('Agent run conversation should be recorded for the caller', () => {expect(partTypes).toContain('text');expect(partTypes).not.toContain('tool-probe');});++ it('should show the owner only the text of a turn another member sent in their thread, with the tool output of the turns the application opened', async () => {+ const threadKey = randomUUID();+ const { threadId } = await runAgent({+ token: globalTestContext.jonyApplicationToken,+ threadKey,+ steps: TOOL_CALL_STEPS,+ });++ await runAgent({+ token: globalTestContext.janeApplicationToken,+ threadKey,+ steps: TOOL_CALL_STEPS,+ });++ await runAgent({+ token: globalTestContext.applicationToken,+ threadKey,+ steps: TOOL_CALL_STEPS,+ });++ const response = await makeMetadataApiRequest(+ {+ query: parse(+ 'query($threadId: UUID!) { chatMessages(threadId: $threadId) { senderWorkspaceMemberId parts { type } } }',+ ),+ variables: { threadId },+ },+ APPLE_JONY_MEMBER_ACCESS_TOKEN,+ );++ expect(response.body.errors).toBeUndefined();++ const messages: {+ senderWorkspaceMemberId: string | null;+ parts: { type: string }[];+ }[] = response.body.data.chatMessages;+ const partTypes = messages.flatMap(({ parts }) =>+ parts.map(({ type }) => type),+ );++ expect(+ messages.map(({ senderWorkspaceMemberId }) => senderWorkspaceMemberId),+ ).toContain(WORKSPACE_MEMBER_DATA_SEED_IDS.JANE);+ expect(partTypes.filter((type) => type === 'tool-probe')).toHaveLength(2);+ });});