agent-tower 0.4.16-beta.0 → 0.4.16-beta.3

package/dist/services/__tests__/team-reconciler.service.test.js

@@ -194,6 +194,22 @@ async function createFixture(options = {}) {
     }
     return { project, task, workspace, teamRun, members };
 }
+async function createMemberPreset(options = {}) {
+    const name = options.name ?? 'Leader';
+    return prisma.memberPreset.create({
+        data: {
+            name,
+            aliases: stringifyJson([name.toLowerCase()]),
+            providerId: `provider-${name.toLowerCase()}`,
+            rolePrompt: `${name} role`,
+            capabilities: stringifyJson(capabilities),
+            workspacePolicy: 'shared',
+            triggerPolicy: options.triggerPolicy ?? 'USER_MESSAGES',
+            sessionPolicy: 'new_per_request',
+            avatar: null,
+        },
+    });
+}
 async function createWorkRequest(options) {
     return prisma.workRequest.create({
         data: {
@@ -279,6 +295,9 @@ describe('TeamReconcilerService', () => {
         await prisma.roomMessage.deleteMany();
         await prisma.teamMember.deleteMany();
         await prisma.teamRun.deleteMany();
+        await prisma.teamTemplateMember.deleteMany();
+        await prisma.teamTemplate.deleteMany();
+        await prisma.memberPreset.deleteMany();
         await prisma.session.deleteMany();
         await prisma.workspace.deleteMany();
         await prisma.task.deleteMany();
@@ -588,16 +607,30 @@ describe('TeamReconcilerService', () => {
                 senderId: members[0].id,
                 senderInvocationId: invocation.id,
             });
-            await expect(prisma.workRequest.findFirst({
-                where: {
-                    teamRunId: teamRun.id,
-                    triggerMessageId: message.id,
-                    targetMemberId: members[1].id,
-                },
-            })).resolves.toMatchObject({
-                requesterType: 'agent',
-                requesterMemberId: members[0].id,
-                status: 'QUEUED',
+            let createdRequestId = '';
+            await vi.waitFor(async () => {
+                const createdRequest = await prisma.workRequest.findFirst({
+                    where: {
+                        teamRunId: teamRun.id,
+                        triggerMessageId: message.id,
+                        targetMemberId: members[1].id,
+                    },
+                });
+                expect(createdRequest).toMatchObject({
+                    requesterType: 'agent',
+                    requesterMemberId: members[0].id,
+                    status: 'STARTED',
+                });
+                createdRequestId = createdRequest.id;
+            });
+            await vi.waitFor(async () => {
+                await expect(prisma.agentInvocation.findFirst({
+                    where: { workRequestId: createdRequestId },
+                })).resolves.toMatchObject({
+                    memberId: members[1].id,
+                    sessionId: null,
+                    status: 'FAILED',
+                });
             });
         }
         finally {
@@ -693,16 +726,30 @@ describe('TeamReconcilerService', () => {
                 senderId: members[0].id,
                 senderInvocationId: invocation.id,
             });
-            await expect(prisma.workRequest.findFirst({
-                where: {
-                    teamRunId: teamRun.id,
-                    triggerMessageId: message.id,
-                    targetMemberId: members[1].id,
-                },
-            })).resolves.toMatchObject({
-                requesterType: 'agent',
-                requesterMemberId: members[0].id,
-                status: 'QUEUED',
+            let createdRequestId = '';
+            await vi.waitFor(async () => {
+                const createdRequest = await prisma.workRequest.findFirst({
+                    where: {
+                        teamRunId: teamRun.id,
+                        triggerMessageId: message.id,
+                        targetMemberId: members[1].id,
+                    },
+                });
+                expect(createdRequest).toMatchObject({
+                    requesterType: 'agent',
+                    requesterMemberId: members[0].id,
+                    status: 'STARTED',
+                });
+                createdRequestId = createdRequest.id;
+            });
+            await vi.waitFor(async () => {
+                await expect(prisma.agentInvocation.findFirst({
+                    where: { workRequestId: createdRequestId },
+                })).resolves.toMatchObject({
+                    memberId: members[1].id,
+                    sessionId: null,
+                    status: 'FAILED',
+                });
             });
         }
         finally {
@@ -736,7 +783,19 @@ describe('TeamReconcilerService', () => {
     it('lists TeamRun members through MCP without exposing role prompts', async () => {
         const previousTeamRunId = process.env.AGENT_TOWER_TEAM_RUN_ID;
         const previousMemberId = process.env.AGENT_TOWER_MEMBER_ID;
-        const { teamRun, members } = await createFixture({ memberCount: 2 });
+        const { workspace, teamRun, members } = await createFixture({ memberCount: 2 });
+        const runningRequest = await createWorkRequest({
+            teamRunId: teamRun.id,
+            targetMemberId: members[0].id,
+            status: 'STARTED',
+        });
+        await createRunningInvocation({
+            teamRunId: teamRun.id,
+            workRequestId: runningRequest.id,
+            memberId: members[0].id,
+            workspaceId: workspace.id,
+            status: 'RUNNING',
+        });
         const app = Fastify({ logger: false });
         try {
             process.env.AGENT_TOWER_TEAM_RUN_ID = teamRun.id;
@@ -771,7 +830,7 @@ describe('TeamReconcilerService', () => {
                 id: members[0].id,
                 name: 'Member 1',
                 aliases: ['member-1'],
-                status: 'IDLE',
+                status: 'RUNNING',
                 workspacePolicy: 'shared',
                 triggerPolicy: 'MENTION_ONLY',
                 sessionPolicy: 'new_per_request',
@@ -948,6 +1007,11 @@ describe('TeamReconcilerService', () => {
             triggerPolicies: ['USER_MESSAGES', 'MENTION_ONLY'],
         });
         const routeScheduler = createRouteSchedulerMock();
+        const startedTeamRunIds = [];
+        routeScheduler.startNextSessions = vi.fn(async (teamRunId) => {
+            startedTeamRunIds.push(teamRunId);
+            return await new Promise(() => { });
+        });
         const app = Fastify({ logger: false });
         try {
             await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
@@ -963,22 +1027,456 @@ describe('TeamReconcilerService', () => {
             const message = response.json();
             expect(message.mentions).toEqual([]);
             expect(message.workRequestIds).toHaveLength(1);
-            expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
-            expect(routeScheduler.startedTeamRunIds).toEqual([teamRun.id]);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
             await expect(prisma.workRequest.findUnique({ where: { id: message.workRequestIds[0] } })).resolves.toMatchObject({
                 targetMemberId: members[0].id,
                 instruction: '普通用户消息',
-                status: 'STARTED',
+                status: 'QUEUED',
             });
             await expect(prisma.agentInvocation.count({
                 where: {
                     teamRunId: teamRun.id,
                     memberId: members[0].id,
-                    status: 'RUNNING',
                 },
-            })).resolves.toBe(1);
+            })).resolves.toBe(0);
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+                expect(startedTeamRunIds).toEqual([teamRun.id]);
+            });
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('creates an initial Team Room message without WorkRequests for unmentioned MENTION_ONLY members', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Initial message project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Build CSV import',
+                description: 'Parse uploaded files and show validation errors.',
+                projectId: project.id,
+            },
+        });
+        const implementerPreset = await createMemberPreset({ name: 'Implementer', triggerPolicy: 'MENTION_ONLY' });
+        const reviewerPreset = await createMemberPreset({ name: 'Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [implementerPreset.id, reviewerPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            const initialContent = 'Build CSV import\n\nParse uploaded files and show validation errors.';
+            expect(teamRun.messages).toHaveLength(1);
+            expect(teamRun.messages[0]).toMatchObject({
+                senderType: 'user',
+                kind: 'chat',
+                content: initialContent,
+                mentions: [],
+                workRequestIds: [],
+            });
+            expect(teamRun.workRequests).toEqual([]);
+            const messagesResponse = await app.inject({
+                method: 'GET',
+                url: `/api/team-runs/${teamRun.id}/messages`,
+            });
+            expect(messagesResponse.statusCode).toBe(200);
+            const messages = messagesResponse.json();
+            expect(messages).toEqual([
+                expect.objectContaining({
+                    id: teamRun.messages[0].id,
+                    content: initialContent,
+                    mentions: [],
+                    workRequestIds: [],
+                }),
+            ]);
+            const workRequestsResponse = await app.inject({
+                method: 'GET',
+                url: `/api/team-runs/${teamRun.id}/work-requests`,
+            });
+            expect(workRequestsResponse.statusCode).toBe(200);
+            const workRequests = workRequestsResponse.json();
+            expect(workRequests).toEqual([]);
+            await expect(prisma.roomMessage.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(1);
+            await expect(prisma.workRequest.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+            await expect(prisma.agentInvocation.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('creates USER_MESSAGES WorkRequests from a title-only initial message and auto-starts it', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Title-only project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Investigate slow dashboard',
+                projectId: project.id,
+            },
+        });
+        const preset = await createMemberPreset({ name: 'Leader', triggerPolicy: 'USER_MESSAGES' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            expect(teamRun.messages).toHaveLength(1);
+            expect(teamRun.messages[0]).toMatchObject({
+                content: 'Investigate slow dashboard',
+                workRequestIds: [teamRun.workRequests[0].id],
+            });
+            expect(teamRun.workRequests[0]).toMatchObject({
+                instruction: 'Investigate slow dashboard',
+                status: 'QUEUED',
+            });
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+            });
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('creates an initial WorkRequest only for a mentioned MENTION_ONLY member', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Mentioned initial message project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Investigate import failures',
+                description: 'Please @Reviewer check the error handling.',
+                projectId: project.id,
+            },
+        });
+        const implementerPreset = await createMemberPreset({ name: 'Implementer', triggerPolicy: 'MENTION_ONLY' });
+        const reviewerPreset = await createMemberPreset({ name: 'Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [implementerPreset.id, reviewerPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            const reviewer = teamRun.members.find((member) => member.name === 'Reviewer');
+            const implementer = teamRun.members.find((member) => member.name === 'Implementer');
+            const initialContent = 'Investigate import failures\n\nPlease @Reviewer check the error handling.';
+            expect(reviewer).toBeDefined();
+            expect(implementer).toBeDefined();
+            expect(teamRun.messages).toHaveLength(1);
+            expect(teamRun.messages[0]).toMatchObject({
+                content: initialContent,
+                mentions: [{ memberId: reviewer.id, label: 'Reviewer' }],
+            });
+            expect(teamRun.workRequests).toEqual([
+                expect.objectContaining({
+                    id: teamRun.messages[0].workRequestIds[0],
+                    targetMemberId: reviewer.id,
+                    instruction: initialContent,
+                    status: 'QUEUED',
+                }),
+            ]);
+            expect(teamRun.workRequests[0].targetMemberId).not.toBe(implementer.id);
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+            });
+            await expect(prisma.agentInvocation.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(1);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('matches initial @mention tokens exactly instead of matching name prefixes', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Mention prefix project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Route QA review',
+                description: 'Please @QA-Lead verify the release notes.',
+                projectId: project.id,
+            },
+        });
+        const qaPreset = await createMemberPreset({ name: 'QA', triggerPolicy: 'MENTION_ONLY' });
+        const qaLeadPreset = await createMemberPreset({ name: 'QA-Lead', triggerPolicy: 'MENTION_ONLY' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [qaPreset.id, qaLeadPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            const qa = teamRun.members.find((member) => member.name === 'QA');
+            const qaLead = teamRun.members.find((member) => member.name === 'QA-Lead');
+            expect(qa).toBeDefined();
+            expect(qaLead).toBeDefined();
+            expect(teamRun.messages[0].mentions).toEqual([{ memberId: qaLead.id, label: 'QA-Lead' }]);
+            expect(teamRun.workRequests).toEqual([
+                expect.objectContaining({
+                    id: teamRun.messages[0].workRequestIds[0],
+                    targetMemberId: qaLead.id,
+                }),
+            ]);
+            expect(teamRun.workRequests[0].targetMemberId).not.toBe(qa.id);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('does not create initial WorkRequests for ambiguous @mention aliases', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Ambiguous mention project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Review ambiguous owner',
+                description: 'Please @reviewer check this.',
+                projectId: project.id,
+            },
+        });
+        const firstPreset = await createMemberPreset({ name: 'Frontend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const secondPreset = await createMemberPreset({ name: 'Backend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        await prisma.memberPreset.updateMany({
+            where: { id: { in: [firstPreset.id, secondPreset.id] } },
+            data: { aliases: stringifyJson(['reviewer']) },
+        });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [firstPreset.id, secondPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            expect(teamRun.messages[0]).toMatchObject({
+                mentions: [],
+                workRequestIds: [],
+            });
+            expect(teamRun.workRequests).toEqual([]);
+            await expect(prisma.workRequest.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('does not fall back to USER_MESSAGES when initial @mention aliases are ambiguous', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Mixed ambiguous mention project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Route ambiguous review',
+                description: 'Please @reviewer decide who owns this.',
+                projectId: project.id,
+            },
+        });
+        const firstPreset = await createMemberPreset({ name: 'Frontend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const secondPreset = await createMemberPreset({ name: 'Backend Reviewer', triggerPolicy: 'MENTION_ONLY' });
+        const observerPreset = await createMemberPreset({ name: 'Observer', triggerPolicy: 'USER_MESSAGES' });
+        await prisma.memberPreset.updateMany({
+            where: { id: { in: [firstPreset.id, secondPreset.id] } },
+            data: { aliases: stringifyJson(['reviewer']) },
+        });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [firstPreset.id, secondPreset.id, observerPreset.id],
+                },
+            });
+            expect(response.statusCode).toBe(201);
+            const teamRun = response.json();
+            expect(teamRun.messages[0]).toMatchObject({
+                mentions: [],
+                workRequestIds: [],
+            });
+            expect(teamRun.workRequests).toEqual([]);
+            await expect(prisma.workRequest.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('rejects creating a TeamRun for a blank-title task before writing TeamRun data', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Blank title project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: '   ',
+                projectId: project.id,
+            },
+        });
+        const preset = await createMemberPreset({ name: 'Leader', triggerPolicy: 'USER_MESSAGES' });
+        const routeScheduler = createRouteSchedulerMock();
+        const app = Fastify({ logger: false });
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const response = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(response.statusCode).toBe(400);
+            expect(response.json()).toMatchObject({ code: 'VALIDATION_ERROR' });
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+            await expect(prisma.teamRun.count({ where: { taskId: task.id } })).resolves.toBe(0);
+            await expect(prisma.roomMessage.count()).resolves.toBe(0);
+            await expect(prisma.workRequest.count()).resolves.toBe(0);
+        }
+        finally {
+            await app.close();
+        }
+    });
+    it('rolls back TeamRun creation when initial WorkRequest creation fails and allows retry', async () => {
+        const project = await prisma.project.create({
+            data: {
+                name: 'Atomic TeamRun project',
+                repoPath: testDir,
+            },
+        });
+        const task = await prisma.task.create({
+            data: {
+                title: 'Start atomically',
+                projectId: project.id,
+            },
+        });
+        const preset = await createMemberPreset({ name: 'Implementer', triggerPolicy: 'USER_MESSAGES' });
+        const routeScheduler = createRouteSchedulerMock();
+        const originalTransaction = prisma.$transaction.bind(prisma);
+        const transactionSpy = vi.spyOn(prisma, '$transaction');
+        transactionSpy.mockImplementationOnce(async (arg, ...rest) => {
+            if (typeof arg !== 'function') {
+                return originalTransaction(arg, ...rest);
+            }
+            return originalTransaction(async (tx) => {
+                const failingTx = new Proxy(tx, {
+                    get(target, property, receiver) {
+                        if (property !== 'workRequest') {
+                            return Reflect.get(target, property, receiver);
+                        }
+                        const delegate = Reflect.get(target, property, receiver);
+                        return new Proxy(delegate, {
+                            get(delegateTarget, delegateProperty, delegateReceiver) {
+                                if (delegateProperty === 'create') {
+                                    return async () => {
+                                        throw new Error('injected initial WorkRequest failure');
+                                    };
+                                }
+                                return Reflect.get(delegateTarget, delegateProperty, delegateReceiver);
+                            },
+                        });
+                    },
+                });
+                return arg(failingTx);
+            }, ...rest);
+        });
+        const app = Fastify({ logger: false });
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        try {
+            await app.register(teamRunRoutes, { prefix: '/api', scheduler: routeScheduler });
+            const failedResponse = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(failedResponse.statusCode).toBe(500);
+            expect(routeScheduler.startNextSessions).not.toHaveBeenCalled();
+            await expect(prisma.teamRun.count({ where: { taskId: task.id } })).resolves.toBe(0);
+            await expect(prisma.teamMember.count()).resolves.toBe(0);
+            await expect(prisma.roomMessage.count()).resolves.toBe(0);
+            await expect(prisma.workRequest.count()).resolves.toBe(0);
+            const retryResponse = await app.inject({
+                method: 'POST',
+                url: `/api/tasks/${task.id}/team-runs`,
+                payload: {
+                    mode: 'AUTO',
+                    memberPresetIds: [preset.id],
+                },
+            });
+            expect(retryResponse.statusCode).toBe(201);
+            const teamRun = retryResponse.json();
+            expect(teamRun.messages[0].workRequestIds).toEqual([teamRun.workRequests[0].id]);
+            expect(teamRun.workRequests[0]).toMatchObject({ status: 'QUEUED' });
+            await vi.waitFor(() => {
+                expect(routeScheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+            });
         }
         finally {
+            consoleErrorSpy.mockRestore();
             await app.close();
         }
     });