Skip to content

The open alternative to Salesforce, designed for AI.

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.ts
index 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/ap
import { 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-e
import { 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 on
instructions: 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 conversation
async 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.ts
index 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.ts
index 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.ts
index 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/engi
import { 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 inbox
isArchived?: boolean;
+ isSubscribed?: boolean;
// checked by the caller, as the member must be able to reach it
channelId?: 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 NULL
RETURNING *
), 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::boolean
FROM thread
ON CONFLICT ("threadId", "workspaceMemberId") DO NOTHING
RETURNING 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.ts
index 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 them
async 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.ts
index 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/actor
import { 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.ts
index 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.ts
index 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-module
import { 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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);
+ });
});