Skip to content

⭐️⭐️⭐️ Open-source, self-hosted alternative to Linear and Plane. Project management and issue tracking where teams and AI agents work side by side to plan and ship products.

fix(api): serialize external agent chat replies by thread (#461)

Denis Zabozhanoved2eaac8d961
diff --git a/apps/api/src/modules/agents/chat/__tests__/integration/agent-chat.test.ts b/apps/api/src/modules/agents/chat/__tests__/integration/agent-chat.test.ts
index a4b9c2e9..d60ff0ae 100644
--- a/apps/api/src/modules/agents/chat/__tests__/integration/agent-chat.test.ts
+++ b/apps/api/src/modules/agents/chat/__tests__/integration/agent-chat.test.ts
@@ -301,6 +301,190 @@ describe('external agent chat', () => {
expect((await asRunner['agent-chats'].claim.post()).data!.message).toBeNull();
});
+ for (const bound of [false, true]) {
+ it(`serializes concurrent claims in a ${bound ? 'bound' : 'fresh'} thread`, async () => {
+ const { asOwner, asRunner, agent } = await setup();
+ const first = (await send(asOwner, agent.id, 'First')).data!;
+ if (bound) {
+ const seed = (await asRunner['agent-chats'].claim.post()).data!.message!;
+ await asRunner['agent-chats']({ messageId: seed.id }).events.post({
+ sessionId: 'existing-session',
+ events: [{ type: 'RUN_STARTED' }],
+ });
+ await asRunner['agent-chats']({ messageId: seed.id }).result.post({ status: 'success' });
+ }
+ const queued = await Promise.all(
+ ['Second', 'Third', 'Fourth'].map((prompt) =>
+ send(asOwner, agent.id, prompt, first.threadId),
+ ),
+ );
+ const expectedIds = [
+ ...(bound ? [] : [first.messageId]),
+ ...queued.map((sent) => sent.data!.messageId).sort((a, b) => a - b),
+ ];
+ for (const id of expectedIds) {
+ const runners = [asRunner, asRunner, asRunner, asRunner];
+ const claims = await Promise.all(
+ runners.map((runner) => runner['agent-chats'].claim.post()),
+ );
+ expect(claims.map((claim) => claim.status)).toEqual([200, 200, 200, 200]);
+ const answers = claims.flatMap((claim) =>
+ claim.data!.message ? [claim.data!.message] : [],
+ );
+ expect(answers).toHaveLength(1);
+ expect(answers[0]).toMatchObject({
+ id,
+ attempts: 1,
+ sessionId: bound ? 'existing-session' : null,
+ });
+ await asRunner['agent-chats']({ messageId: id }).result.post({ status: 'success' });
+ }
+ });
+ }
+
+ it('binds the initial session before issuing the next answer', async () => {
+ const { asOwner, asRunner, agent } = await setup();
+ const first = (await send(asOwner, agent.id, 'First')).data!;
+ const second = (await send(asOwner, agent.id, 'Second', first.threadId)).data!;
+ const claimed = (await asRunner['agent-chats'].claim.post()).data!.message!;
+ expect(claimed).toMatchObject({ id: first.messageId, sessionId: null });
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toBeNull();
+ await asRunner['agent-chats']({ messageId: claimed.id }).events.post({
+ sessionId: 'new-session',
+ events: [{ type: 'RUN_STARTED' }],
+ });
+ await asRunner['agent-chats']({ messageId: claimed.id }).result.post({ status: 'success' });
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toMatchObject({
+ id: second.messageId,
+ sessionId: 'new-session',
+ prompt: 'Second',
+ systemPrompt: '',
+ });
+ });
+
+ it('claims different threads concurrently while keeping each next answer queued', async () => {
+ const { asOwner, asRunner, agent } = await setup();
+ const first = (await send(asOwner, agent.id, 'One')).data!;
+ const other = (await send(asOwner, agent.id, 'Other')).data!;
+ await send(asOwner, agent.id, 'Later', first.threadId);
+ const claims = await Promise.all([
+ asRunner['agent-chats'].claim.post(),
+ asRunner['agent-chats'].claim.post(),
+ ]);
+ expect(claims.map((claim) => claim.data!.message!.id).sort((a, b) => a - b)).toEqual([
+ first.messageId,
+ other.messageId,
+ ]);
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toBeNull();
+ });
+
+ for (const status of ['success', 'failed', 'canceled'] as const) {
+ it(`advances past a ${status} answer and skips a canceled queued answer`, async () => {
+ const { asOwner, asRunner, agent } = await setup();
+ const first = (await send(asOwner, agent.id, 'First')).data!;
+ const skipped = (await send(asOwner, agent.id, 'Skip', first.threadId)).data!;
+ const next = (await send(asOwner, agent.id, 'Next', first.threadId)).data!;
+ expect((await asRunner['agent-chats'].claim.post()).data!.message!.id).toBe(first.messageId);
+ await chatOf(asOwner, agent.id).chat({ messageId: skipped.messageId }).cancel.post();
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toBeNull();
+ if (status === 'canceled') {
+ await chatOf(asOwner, agent.id).chat({ messageId: first.messageId }).cancel.post();
+ } else {
+ await asRunner['agent-chats']({ messageId: first.messageId }).result.post({ status });
+ }
+ expect((await asRunner['agent-chats'].claim.post()).data!.message!.id).toBe(next.messageId);
+ });
+ }
+
+ it('recovers the oldest expired lease and advances after exhausted attempts', async () => {
+ const previousLease = process.env.AGENT_CHAT_LEASE_SECONDS;
+ const previousAttempts = process.env.AGENT_CHAT_MAX_ATTEMPTS;
+ process.env.AGENT_CHAT_LEASE_SECONDS = '1';
+ process.env.AGENT_CHAT_MAX_ATTEMPTS = '2';
+ try {
+ const { asOwner, asRunner, agent } = await setup();
+ const first = (await send(asOwner, agent.id, 'First')).data!;
+ const next = (await send(asOwner, agent.id, 'Next', first.threadId)).data!;
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toMatchObject({
+ id: first.messageId,
+ attempts: 1,
+ });
+ await asRunner['agent-chats']({ messageId: first.messageId }).events.post({
+ events: [{ type: 'TEXT_MESSAGE_CONTENT', messageId: 'm1', delta: 'abandoned' }],
+ });
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toBeNull();
+ await Bun.sleep(1100);
+ const claims = await Promise.all([
+ asRunner['agent-chats'].claim.post(),
+ asRunner['agent-chats'].claim.post(),
+ ]);
+ const answers = claims.flatMap((claim) => (claim.data!.message ? [claim.data!.message] : []));
+ expect(answers).toHaveLength(1);
+ expect(answers[0]).toMatchObject({ id: first.messageId, attempts: 2 });
+ const events = await chatOf(asOwner, agent.id)
+ .chat({ messageId: first.messageId })
+ .events.get();
+ expect(events.data!.items).toEqual([]);
+ await Bun.sleep(1100);
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toMatchObject({
+ id: next.messageId,
+ attempts: 1,
+ });
+ const failed = await chatOf(asOwner, agent.id)
+ .chat({ messageId: first.messageId })
+ .events.get();
+ expect(failed.data!).toMatchObject({
+ status: 'failed',
+ error: 'Runner did not report a result',
+ });
+ } finally {
+ if (previousLease === undefined) delete process.env.AGENT_CHAT_LEASE_SECONDS;
+ else process.env.AGENT_CHAT_LEASE_SECONDS = previousLease;
+ if (previousAttempts === undefined) delete process.env.AGENT_CHAT_MAX_ATTEMPTS;
+ else process.env.AGENT_CHAT_MAX_ATTEMPTS = previousAttempts;
+ }
+ });
+
+ it('claims another thread when an exhausted head expires during a long poll', async () => {
+ const previousLease = process.env.AGENT_CHAT_LEASE_SECONDS;
+ const previousAttempts = process.env.AGENT_CHAT_MAX_ATTEMPTS;
+ const previousWait = process.env.AGENT_CHAT_CLAIM_WAIT_MS;
+ process.env.AGENT_CHAT_LEASE_SECONDS = '1';
+ process.env.AGENT_CHAT_MAX_ATTEMPTS = '1';
+ process.env.AGENT_CHAT_CLAIM_WAIT_MS = '2500';
+ try {
+ const { asOwner, asRunner, agent } = await setup();
+ const first = (await send(asOwner, agent.id, 'First')).data!;
+ expect((await asRunner['agent-chats'].claim.post()).data!.message).toMatchObject({
+ id: first.messageId,
+ attempts: 1,
+ });
+ const waiting = asRunner['agent-chats'].claim.post();
+ try {
+ await Bun.sleep(1100);
+ const expired = await chatOf(asOwner, agent.id)
+ .chat({ messageId: first.messageId })
+ .events.get();
+ expect(expired.data!.status).toBe('streaming');
+ const other = (await send(asOwner, agent.id, 'Other')).data!;
+ expect((await waiting).data!.message).toMatchObject({
+ id: other.messageId,
+ threadId: other.threadId,
+ attempts: 1,
+ });
+ } finally {
+ await waiting;
+ }
+ } finally {
+ if (previousLease === undefined) delete process.env.AGENT_CHAT_LEASE_SECONDS;
+ else process.env.AGENT_CHAT_LEASE_SECONDS = previousLease;
+ if (previousAttempts === undefined) delete process.env.AGENT_CHAT_MAX_ATTEMPTS;
+ else process.env.AGENT_CHAT_MAX_ATTEMPTS = previousAttempts;
+ if (previousWait === undefined) delete process.env.AGENT_CHAT_CLAIM_WAIT_MS;
+ else process.env.AGENT_CHAT_CLAIM_WAIT_MS = previousWait;
+ }
+ });
+
it('reports events back with a cursor and builds the answer text from them', async () => {
const { asOwner, asRunner, agent } = await setup();
const sent = await send(asOwner, agent.id, 'Summarise the sprint');
diff --git a/apps/api/src/modules/agents/chat/service.ts b/apps/api/src/modules/agents/chat/service.ts
index 9d2d847f..f59cb36a 100644
--- a/apps/api/src/modules/agents/chat/service.ts
+++ b/apps/api/src/modules/agents/chat/service.ts
@@ -436,33 +436,62 @@ export async function claimNextMessage(agent: RunnerAgent): Promise<ClaimedChat
// a previous attempt produced: the answer is generated again from the start, and the
// browser would otherwise read the abandoned half twice.
async function claimMessage(agent: RunnerAgent): Promise<ClaimedChat | null> {
- const rows = await db.execute(sql`
- UPDATE agent_chat_message m
- SET attempts = m.attempts + 1,
- status = 'streaming',
- content = '',
- started_at = coalesce(m.started_at, now()),
- next_attempt_at = now() + make_interval(secs => ${agentChatConfig.leaseSeconds()})
- WHERE m.id = (
- SELECT id FROM agent_chat_message q
- WHERE q.agent_id = ${agent.id}
- AND q.role = 'assistant'
- AND q.status IN ('pending', 'streaming')
- AND q.next_attempt_at <= now()
- ORDER BY q.next_attempt_at, q.id
- FOR UPDATE SKIP LOCKED
+ const rows = await db.transaction(async (tx) => {
+ const threads = await tx.execute(sql`
+ WITH live_heads AS MATERIALIZED (
+ SELECT q.thread_id, min(q.id) AS id FROM agent_chat_message q
+ WHERE q.agent_id = ${agent.id}
+ AND q.role = 'assistant'
+ AND q.status IN ('pending', 'streaming')
+ GROUP BY q.thread_id
+ ), ready_heads AS MATERIALIZED (
+ SELECT h.thread_id FROM live_heads h
+ JOIN agent_chat_message head ON head.id = h.id
+ WHERE head.next_attempt_at <= now()
+ AND head.attempts < ${agentChatConfig.maxAttempts()}
+ ORDER BY head.next_attempt_at, head.id
+ )
+ SELECT t.id FROM ready_heads h
+ CROSS JOIN LATERAL (
+ SELECT t.id FROM agent_chat_thread t
+ WHERE t.id = h.thread_id AND t.agent_id = ${agent.id}
+ FOR UPDATE SKIP LOCKED
+ ) t
LIMIT 1
- )
- RETURNING
- m.id,
- m.thread_id AS "threadId",
- m.attempts,
- (SELECT u.name FROM agent_chat_thread t JOIN "user" u ON u.id = t.user_id
- WHERE t.id = m.thread_id) AS "requesterName",
- (SELECT u.username FROM agent_chat_thread t JOIN "user" u ON u.id = t.user_id
- WHERE t.id = m.thread_id) AS "requesterUsername",
- (SELECT cli_session_id FROM agent_chat_thread t WHERE t.id = m.thread_id) AS "sessionId"
- `);
+ `);
+ const thread = (threads as unknown as { id: string }[])[0];
+ if (!thread) return [];
+ // Re-read the first unfinished answer after taking the thread lock: a concurrent
+ // claim may have committed while the thread selection used an earlier snapshot.
+ return tx.execute(sql`
+ UPDATE agent_chat_message m
+ SET attempts = m.attempts + 1,
+ status = 'streaming',
+ content = '',
+ started_at = coalesce(m.started_at, now()),
+ next_attempt_at = now() + make_interval(secs => ${agentChatConfig.leaseSeconds()})
+ WHERE m.id = (
+ SELECT q.id FROM agent_chat_message q
+ WHERE q.thread_id = ${thread.id}
+ AND q.role = 'assistant'
+ AND q.status IN ('pending', 'streaming')
+ ORDER BY q.id
+ LIMIT 1
+ )
+ AND m.status IN ('pending', 'streaming')
+ AND m.next_attempt_at <= now()
+ AND m.attempts < ${agentChatConfig.maxAttempts()}
+ RETURNING
+ m.id,
+ m.thread_id AS "threadId",
+ m.attempts,
+ (SELECT u.name FROM agent_chat_thread t JOIN "user" u ON u.id = t.user_id
+ WHERE t.id = m.thread_id) AS "requesterName",
+ (SELECT u.username FROM agent_chat_thread t JOIN "user" u ON u.id = t.user_id
+ WHERE t.id = m.thread_id) AS "requesterUsername",
+ (SELECT cli_session_id FROM agent_chat_thread t WHERE t.id = m.thread_id) AS "sessionId"
+ `);
+ });
const row = (rows as unknown as ClaimedRow[])[0];
if (!row) return null;
await db.delete(agentChatEvent).where(eq(agentChatEvent.messageId, row.id));