Skip to content

The open alternative to Salesforce, designed for AI.

Set up the inbox state of threads created through the record API (#27553)

Félix Malfait5fcbee6bb197
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/__tests__/agent-chat-thread-create.post-query.hook.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/__tests__/agent-chat-thread-create.post-query.hook.spec.ts
new file mode 100644
index 00000000000..6a4d62db223
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/__tests__/agent-chat-thread-create.post-query.hook.spec.ts
@@ -0,0 +1,319 @@
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { AgentChatThreadCreateManyPostQueryHook } from 'src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-many.post-query.hook';
+import { AgentChatThreadCreateOnePostQueryHook } from 'src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-one.post-query.hook';
+import { AgentChatSharingService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service';
+import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
+
+const WORKSPACE_ID = '20202020-1111-4111-8111-111111111111';
+const CREATOR_ID = 'creator-member-id';
+const CREATOR_USER_WORKSPACE_ID = 'creator-user-workspace-id';
+const PARTICIPANT_OBJECT_METADATA_ID = 'participant-object-metadata-id';
+const LAST_ACTIVITY_AT = '2026-10-07T10:00:00.000Z';
+
+const creatorAuthContext = {
+ type: 'user',
+ workspace: { id: WORKSPACE_ID },
+ workspaceMemberId: CREATOR_ID,
+ userWorkspaceId: CREATOR_USER_WORKSPACE_ID,
+} as unknown as WorkspaceAuthContext;
+
+type Thread = {
+ id: string;
+ workspaceMemberId: string | null;
+ lastActivityAt: string | null;
+};
+
+// Stands in for the thread and participant tables, applying the inbox setup
+// the way its SQL does
+const buildStorage = (threads: Thread[]) => {
+ const participants: {
+ threadId: string;
+ workspaceMemberId: string;
+ lastReadAt: string | null;
+ }[] = [];
+
+ const setUpInboxState = (sql: string, parameters: unknown[]) => {
+ expect(sql).toContain('SET "lastActivityAt" = clock_timestamp()');
+
+ const [threadIds, workspaceMemberId] = parameters as [string[], string];
+ const setUpThreads = threads.filter(
+ (thread) =>
+ threadIds.includes(thread.id) && thread.lastActivityAt === null,
+ );
+
+ for (const thread of setUpThreads) {
+ thread.lastActivityAt = LAST_ACTIVITY_AT;
+ participants.push({
+ threadId: thread.id,
+ workspaceMemberId,
+ lastReadAt: thread.lastActivityAt,
+ });
+ }
+
+ return setUpThreads.map((thread) => ({ ...thread }));
+ };
+
+ const manager = {
+ query: jest.fn(async (sql: string, parameters: unknown[]) => {
+ if (sql.startsWith('INSERT INTO "agentChatThread"')) {
+ const [id, , workspaceMemberId] = parameters as string[];
+ const thread = { id, workspaceMemberId, lastActivityAt: null };
+
+ threads.push(thread);
+
+ return [thread];
+ }
+
+ if (sql.includes('"agentChatThreadParticipant"')) {
+ return setUpInboxState(sql, parameters);
+ }
+
+ if (sql.includes('"recordShare"')) {
+ return [{ id: 'owner-grant-id' }];
+ }
+
+ throw new Error(`Unexpected query: ${sql}`);
+ }),
+ };
+
+ const threadRepository = {
+ find: jest.fn(
+ async (
+ _workspaceId: string,
+ {
+ where,
+ }: { where: { id: { value: string[] }; workspaceMemberId?: unknown } },
+ ) =>
+ threads
+ .filter(
+ (thread) =>
+ where.id.value.includes(thread.id) &&
+ (!('workspaceMemberId' in where) ||
+ thread.workspaceMemberId === null),
+ )
+ .map((thread) => ({ ...thread })),
+ ),
+ update: jest.fn(
+ async (
+ _workspaceId: string,
+ { id }: { id: { value: string[] } },
+ { workspaceMemberId }: { workspaceMemberId: string },
+ ) => {
+ const assignedThreads = threads.filter(
+ (thread) =>
+ id.value.includes(thread.id) && thread.workspaceMemberId === null,
+ );
+
+ for (const thread of assignedThreads) {
+ thread.workspaceMemberId = workspaceMemberId;
+ }
+
+ return { generatedMaps: assignedThreads.map(({ id }) => ({ id })) };
+ },
+ ),
+ query: jest.fn(
+ async (
+ _workspaceId: string,
+ work: (context: {
+ manager: typeof manager;
+ table: (name: string) => string;
+ }) => Promise<unknown>,
+ ) => work({ manager, table: (name) => `"${name}"` }),
+ ),
+ };
+
+ return { threads, participants, manager, threadRepository };
+};
+
+const buildContext = ({
+ threads = [],
+ hasInboxState = true,
+}: {
+ threads?: Thread[];
+ hasInboxState?: boolean;
+} = {}) => {
+ const storage = buildStorage(threads);
+ const events: string[] = [];
+ const workspaceOrmManager = {
+ executeInWorkspaceContext: jest.fn(async (work: () => unknown) => work()),
+ getRepositoryWithContextPermissions: () => ({
+ validateWriteIsPermitted: jest.fn(),
+ }),
+ };
+ const sharingService = new AgentChatSharingService(
+ storage.threadRepository as never,
+ {} as never,
+ { deleteByRecordIdsInTransaction: jest.fn() } as never,
+ {} as never,
+ {} as never,
+ {} as never,
+ workspaceOrmManager as never,
+ {} as never,
+ );
+
+ jest
+ .spyOn(sharingService, 'findParticipantObjectMetadataId')
+ .mockResolvedValue(
+ hasInboxState ? PARTICIPANT_OBJECT_METADATA_ID : undefined,
+ );
+ jest.spyOn(sharingService, 'getAuthContext').mockResolvedValue({
+ workspaceMemberId: CREATOR_ID,
+ userWorkspaceId: CREATOR_USER_WORKSPACE_ID,
+ } as never);
+ jest
+ .spyOn(
+ sharingService as unknown as {
+ getThreadObjectMetadata: () => Promise<unknown>;
+ },
+ 'getThreadObjectMetadata',
+ )
+ .mockResolvedValue({ id: 'thread-object-metadata-id' });
+
+ const participantService = {
+ emitParticipantCreated: jest.fn(async ({ threadId }) => {
+ events.push(`participant created ${threadId}`);
+ }),
+ };
+ const recordEventService = {
+ emitThreadCreated: jest.fn(async ({ threadId }) => {
+ events.push(`thread created ${threadId}`);
+ }),
+ emitThreadUpdated: jest.fn(async ({ threadBefore }) => {
+ events.push(`thread updated ${threadBefore.id}`);
+ }),
+ };
+ const threadService = new AgentChatThreadService(
+ storage.threadRepository as never,
+ sharingService,
+ recordEventService as never,
+ participantService as never,
+ );
+
+ return {
+ ...storage,
+ events,
+ threadService,
+ recordEventService,
+ createOneHook: new AgentChatThreadCreateOnePostQueryHook(threadService),
+ createManyHook: new AgentChatThreadCreateManyPostQueryHook(threadService),
+ };
+};
+
+describe('agentChatThread record API creation', () => {
+ it('gives the creator a read participant row and sorts the thread by its creation', async () => {
+ const context = buildContext({
+ threads: [
+ { id: 'new-thread', workspaceMemberId: null, lastActivityAt: null },
+ ],
+ });
+
+ await context.createOneHook.execute(creatorAuthContext, 'agentChatThread', [
+ { id: 'new-thread' },
+ ]);
+
+ expect(context.threads).toEqual([
+ {
+ id: 'new-thread',
+ workspaceMemberId: CREATOR_ID,
+ lastActivityAt: LAST_ACTIVITY_AT,
+ },
+ ]);
+ expect(context.participants).toEqual([
+ {
+ threadId: 'new-thread',
+ workspaceMemberId: CREATOR_ID,
+ lastReadAt: LAST_ACTIVITY_AT,
+ },
+ ]);
+ expect(context.events).toEqual([
+ 'participant created new-thread',
+ 'thread updated new-thread',
+ ]);
+ });
+
+ it('sets up every created thread, and leaves alone those another member owns', async () => {
+ const context = buildContext({
+ threads: [
+ { id: 'first-thread', workspaceMemberId: null, lastActivityAt: null },
+ { id: 'second-thread', workspaceMemberId: null, lastActivityAt: null },
+ {
+ id: 'upserted-thread',
+ workspaceMemberId: 'other-member-id',
+ lastActivityAt: null,
+ },
+ ],
+ });
+
+ await context.createManyHook.execute(
+ creatorAuthContext,
+ 'agentChatThread',
+ [
+ { id: 'first-thread' },
+ { id: 'second-thread' },
+ { id: 'upserted-thread' },
+ ],
+ );
+
+ expect(context.participants).toEqual([
+ {
+ threadId: 'first-thread',
+ workspaceMemberId: CREATOR_ID,
+ lastReadAt: LAST_ACTIVITY_AT,
+ },
+ {
+ threadId: 'second-thread',
+ workspaceMemberId: CREATOR_ID,
+ lastReadAt: LAST_ACTIVITY_AT,
+ },
+ ]);
+ expect(context.threads[2]).toEqual({
+ id: 'upserted-thread',
+ workspaceMemberId: 'other-member-id',
+ lastActivityAt: null,
+ });
+ });
+
+ it('only assigns the creator in a workspace whose 2.46 inbox commands have not run', async () => {
+ const context = buildContext({
+ threads: [
+ { id: 'new-thread', workspaceMemberId: null, lastActivityAt: null },
+ ],
+ hasInboxState: false,
+ });
+
+ await context.createOneHook.execute(creatorAuthContext, 'agentChatThread', [
+ { id: 'new-thread' },
+ ]);
+
+ expect(context.manager.query).not.toHaveBeenCalled();
+ expect(context.threads[0]).toEqual({
+ id: 'new-thread',
+ workspaceMemberId: CREATOR_ID,
+ lastActivityAt: null,
+ });
+ expect(context.events).toEqual(['thread updated new-thread']);
+ });
+
+ it('sets up the inbox state the same way as createChatThread', async () => {
+ const context = buildContext();
+
+ const thread = await context.threadService.createThread({
+ workspaceId: WORKSPACE_ID,
+ workspaceMemberId: CREATOR_ID,
+ id: 'chat-thread',
+ });
+
+ expect(thread.lastActivityAt).toBe(LAST_ACTIVITY_AT);
+ expect(context.participants).toEqual([
+ {
+ threadId: 'chat-thread',
+ workspaceMemberId: CREATOR_ID,
+ lastReadAt: LAST_ACTIVITY_AT,
+ },
+ ]);
+ expect(context.events).toEqual([
+ 'participant created chat-thread',
+ 'thread created chat-thread',
+ ]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-many.post-query.hook.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-many.post-query.hook.ts
index 8293b252120..7261d7a79e9 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-many.post-query.hook.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-many.post-query.hook.ts
@@ -5,7 +5,7 @@ import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/work
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-import { AgentChatThreadLifecycleService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service';
+import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { type AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
@Injectable()
@@ -14,16 +14,14 @@ import { type AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules
type: WorkspaceQueryHookType.POST_HOOK,
})
export class AgentChatThreadCreateManyPostQueryHook implements WorkspacePostQueryHookInstance {
- constructor(
- private readonly threadLifecycleService: AgentChatThreadLifecycleService,
- ) {}
+ constructor(private readonly threadService: AgentChatThreadService) {}
async execute(
authContext: WorkspaceAuthContext,
_objectName: string,
payload: Pick<AgentChatThreadWorkspaceEntity, 'id'>[],
): Promise<void> {
- await this.threadLifecycleService.assignCreatedThreadsToCreator({
+ await this.threadService.assignCreatedThreadsToCreator({
authContext,
threadIds: payload.map((thread) => thread.id),
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-one.post-query.hook.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-one.post-query.hook.ts
index 6e2c81d510e..a52421f025d 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-one.post-query.hook.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-one.post-query.hook.ts
@@ -5,7 +5,7 @@ import { type WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/work
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-import { AgentChatThreadLifecycleService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service';
+import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { type AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
@Injectable()
@@ -14,16 +14,14 @@ import { type AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules
type: WorkspaceQueryHookType.POST_HOOK,
})
export class AgentChatThreadCreateOnePostQueryHook implements WorkspacePostQueryHookInstance {
- constructor(
- private readonly threadLifecycleService: AgentChatThreadLifecycleService,
- ) {}
+ constructor(private readonly threadService: AgentChatThreadService) {}
async execute(
authContext: WorkspaceAuthContext,
_objectName: string,
payload: Pick<AgentChatThreadWorkspaceEntity, 'id'>[],
): Promise<void> {
- await this.threadLifecycleService.assignCreatedThreadsToCreator({
+ await this.threadService.assignCreatedThreadsToCreator({
authContext,
threadIds: payload.map((thread) => thread.id),
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-query-hook.module.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-query-hook.module.ts
index 4829c3a79cf..64ff6aa57fe 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-query-hook.module.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-query-hook.module.ts
@@ -1,13 +1,14 @@
import { Module } from '@nestjs/common';
import { AgentChatThreadLifecycleModule } from 'src/engine/metadata-modules/ai/ai-chat/agent-chat-thread-lifecycle.module';
+import { AgentChatThreadModule } from 'src/engine/metadata-modules/ai/ai-chat/agent-chat-thread.module';
import { AgentChatThreadCreateManyPostQueryHook } from 'src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-many.post-query.hook';
import { AgentChatThreadCreateOnePostQueryHook } from 'src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-create-one.post-query.hook';
import { AgentChatThreadDeleteManyPostQueryHook } from 'src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-delete-many.post-query.hook';
import { AgentChatThreadDeleteOnePostQueryHook } from 'src/engine/metadata-modules/ai/ai-chat/query-hooks/agent-chat-thread-delete-one.post-query.hook';
@Module({
- imports: [AgentChatThreadLifecycleModule],
+ imports: [AgentChatThreadLifecycleModule, AgentChatThreadModule],
providers: [
AgentChatThreadCreateOnePostQueryHook,
AgentChatThreadCreateManyPostQueryHook,
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 29e7c11bd66..dcfdbf0e6c1 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
@@ -21,6 +21,7 @@ import { throwAgentChatThreadNotFound } from 'src/engine/metadata-modules/ai/ai-
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';
+import { type AgentHistoryStorageContext } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-workspace-storage.service';
import { AgentHistoryUpgradeFenceService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-upgrade-fence.service';
import {
AiException,
@@ -215,7 +216,6 @@ export class AgentChatSharingService {
const objectMetadata = await this.getThreadObjectMetadata(args.workspaceId);
const participantObjectMetadataId =
await this.findParticipantObjectMetadataId(args.workspaceId);
- const hasInboxState = isDefined(participantObjectMetadataId);
await this.workspaceOrmManager.executeInWorkspaceContext(
() =>
@@ -233,8 +233,8 @@ export class AgentChatSharingService {
args.workspaceId,
async ({ manager, table }) => {
const records = await manager.query<AgentChatThreadWorkspaceEntity[]>(
- `INSERT INTO ${table('agentChatThread')} (id, title, "workspaceMemberId", "userWorkspaceId"${hasInboxState ? ', "lastActivityAt"' : ''})
- VALUES ($1, $2, $3, $4${hasInboxState ? ', clock_timestamp()' : ''}) RETURNING *`,
+ `INSERT INTO ${table('agentChatThread')} (id, title, "workspaceMemberId", "userWorkspaceId")
+ VALUES ($1, $2, $3, $4) RETURNING *`,
[
args.id ?? randomUUID(),
args.title ?? null,
@@ -261,32 +261,66 @@ export class AgentChatSharingService {
AiExceptionCode.THREAD_NOT_FOUND,
);
}
- if (hasInboxState) {
- await manager.query(
- `WITH participant AS (
- INSERT INTO ${getAgentChatThreadParticipantTable(args.workspaceId)} ("threadId", "workspaceMemberId", "lastReadAt", "archivedAt")
- VALUES ($1, $2, $3, CASE WHEN $5::boolean THEN clock_timestamp() END)
- RETURNING id, "workspaceMemberId"
- )
- ${buildAgentChatThreadParticipantOwnerShareInsert({
- workspaceId: args.workspaceId,
- participantSource: 'participant',
- objectMetadataIdParameter: '$4',
- })}`,
- [
- record.id,
- authContext.workspaceMemberId,
- record.lastActivityAt,
- participantObjectMetadataId,
- args.isArchived ?? false,
- ],
- );
- }
- return record;
+ const [setUpRecord] = await this.setUpCreatedThreadsInboxState({
+ manager,
+ table,
+ workspaceId: args.workspaceId,
+ workspaceMemberId: authContext.workspaceMemberId,
+ threadIds: [record.id],
+ participantObjectMetadataId,
+ isArchived: args.isArchived,
+ });
+ return setUpRecord ?? record;
},
);
}
+ // 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.
+ async setUpCreatedThreadsInboxState({
+ manager,
+ table,
+ workspaceId,
+ workspaceMemberId,
+ threadIds,
+ participantObjectMetadataId,
+ isArchived = false,
+ }: AgentHistoryStorageContext & {
+ workspaceId: string;
+ workspaceMemberId: string;
+ threadIds: string[];
+ participantObjectMetadataId: string | undefined;
+ isArchived?: boolean;
+ }): Promise<AgentChatThreadWorkspaceEntity[]> {
+ if (!isDefined(participantObjectMetadataId)) {
+ return [];
+ }
+
+ return manager.query<AgentChatThreadWorkspaceEntity[]>(
+ `WITH thread AS (
+ UPDATE ${table('agentChatThread')}
+ SET "lastActivityAt" = clock_timestamp()
+ 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
+ FROM thread
+ ON CONFLICT ("threadId", "workspaceMemberId") DO NOTHING
+ RETURNING id, "workspaceMemberId"
+ ), owner_share AS (
+ ${buildAgentChatThreadParticipantOwnerShareInsert({
+ workspaceId,
+ participantSource: 'participant',
+ objectMetadataIdParameter: '$3',
+ })}
+ )
+ SELECT * FROM thread`,
+ [threadIds, workspaceMemberId, participantObjectMetadataId, isArchived],
+ );
+ }
+
async restoreThreadWithAccess(
args: AgentChatThreadAccessArgs,
): Promise<AgentChatThreadWorkspaceEntity> {
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts
index d1912f76a3b..3966f55ba4a 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts
@@ -1,11 +1,9 @@
import { Injectable, Logger } from '@nestjs/common';
import { isNonEmptyString } from '@sniptt/guards';
-import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+import { isNonEmptyArray } from 'twenty-shared/utils';
import { In, IsNull, Not } from 'typeorm';
-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 { CodeInterpreterService } from 'src/engine/core-modules/code-interpreter/code-interpreter.service';
import { RedisClientService } from 'src/engine/core-modules/redis-client/redis-client.service';
import { closeOpenToolParts } from 'src/engine/metadata-modules/ai/ai-agent-execution/pausing-tools/utils/close-open-tool-parts.util';
@@ -89,67 +87,6 @@ export class AgentChatThreadLifecycleService {
}
}
- // owned threads are skipped so an upsert cannot reassign them
- async assignCreatedThreadsToCreator({
- authContext,
- threadIds,
- }: {
- authContext: WorkspaceAuthContext;
- threadIds: string[];
- }): Promise<void> {
- if (!isUserAuthContext(authContext) || !isNonEmptyArray(threadIds)) {
- return;
- }
-
- const workspaceId = authContext.workspace.id;
- const unassignedThreadCriteria = { workspaceMemberId: IsNull() };
-
- const threadsBefore = await this.threadRepository.find(workspaceId, {
- where: { id: In(threadIds), ...unassignedThreadCriteria },
- });
-
- if (!isNonEmptyArray(threadsBefore)) {
- return;
- }
-
- const { generatedMaps: assignedThreads } =
- await this.threadRepository.update(
- workspaceId,
- {
- id: In(threadsBefore.map(({ id }) => id)),
- ...unassignedThreadCriteria,
- },
- {
- workspaceMemberId: authContext.workspaceMemberId,
- userWorkspaceId: authContext.userWorkspaceId,
- },
- );
-
- if (!isNonEmptyArray(assignedThreads)) {
- return;
- }
-
- const threadsAfter = await this.threadRepository.find(workspaceId, {
- where: { id: In(assignedThreads.map(({ id }) => id)) },
- });
-
- for (const threadAfter of threadsAfter) {
- const threadBefore = threadsBefore.find(
- ({ id }) => id === threadAfter.id,
- );
-
- if (!isDefined(threadBefore)) {
- continue;
- }
-
- await this.threadRecordEventService.emitThreadUpdated({
- workspaceId,
- threadBefore,
- threadAfter,
- });
- }
- }
-
async stopStreamIfAny({
workspaceId,
thread,
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 6d09e7dbf8c..b7191c3ad17 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
@@ -1,7 +1,10 @@
import { Injectable, Logger } from '@nestjs/common';
-import { isDefined } from 'twenty-shared/utils';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+import { In, IsNull } from 'typeorm';
+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';
import { AgentChatSharingService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service';
import { AgentChatThreadParticipantService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-participant.service';
@@ -52,6 +55,93 @@ export class AgentChatThreadService {
return savedThread;
}
+ // owned threads are skipped so an upsert cannot reassign them
+ async assignCreatedThreadsToCreator({
+ authContext,
+ threadIds,
+ }: {
+ authContext: WorkspaceAuthContext;
+ threadIds: string[];
+ }): Promise<void> {
+ if (!isUserAuthContext(authContext) || !isNonEmptyArray(threadIds)) {
+ return;
+ }
+
+ const workspaceId = authContext.workspace.id;
+ const { workspaceMemberId } = authContext;
+ const unassignedThreadCriteria = { workspaceMemberId: IsNull() };
+
+ const threadsBefore = await this.threadRepository.find(workspaceId, {
+ where: { id: In(threadIds), ...unassignedThreadCriteria },
+ });
+
+ if (!isNonEmptyArray(threadsBefore)) {
+ return;
+ }
+
+ const { generatedMaps: assignedThreads } =
+ await this.threadRepository.update(
+ workspaceId,
+ {
+ id: In(threadsBefore.map(({ id }) => id)),
+ ...unassignedThreadCriteria,
+ },
+ {
+ workspaceMemberId,
+ userWorkspaceId: authContext.userWorkspaceId,
+ },
+ );
+
+ if (!isNonEmptyArray(assignedThreads)) {
+ return;
+ }
+
+ const assignedThreadIds = assignedThreads.map(({ id }) => id);
+ const participantObjectMetadataId =
+ await this.sharingService.findParticipantObjectMetadataId(workspaceId);
+
+ const setUpThreads = await this.threadRepository.query(
+ workspaceId,
+ (context) =>
+ this.sharingService.setUpCreatedThreadsInboxState({
+ ...context,
+ workspaceId,
+ workspaceMemberId,
+ threadIds: assignedThreadIds,
+ participantObjectMetadataId,
+ }),
+ );
+
+ // Sent first, so a new thread never shows as unread to its creator
+ for (const { id: threadId } of setUpThreads) {
+ await this.participantService.emitParticipantCreated({
+ workspaceId,
+ workspaceMemberId,
+ threadId,
+ });
+ }
+
+ const threadsAfter = await this.threadRepository.find(workspaceId, {
+ where: { id: In(assignedThreadIds) },
+ });
+
+ for (const threadAfter of threadsAfter) {
+ const threadBefore = threadsBefore.find(
+ ({ id }) => id === threadAfter.id,
+ );
+
+ if (!isDefined(threadBefore)) {
+ continue;
+ }
+
+ await this.threadRecordEventService.emitThreadUpdated({
+ workspaceId,
+ threadBefore,
+ threadAfter,
+ });
+ }
+ }
+
async findWritableThread(args: AgentChatThreadAccessArgs) {
try {
return await this.getWritableThread(args);