The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsnew file mode 100644index 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.tsindex 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/workimport { 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-modulestype: 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.tsindex 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/workimport { 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-modulestype: 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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);