Skip to content

The open alternative to Salesforce, designed for AI.

Agent engine: park a run behind a busy conversation instead of polling (#28338)

Félix Malfait8da8836e4716
diff --git a/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts b/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts
index 9c717b0a2e5..f31840e992a 100644
--- a/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts
+++ b/packages/twenty-server/src/database/commands/agent-history/__tests__/agent-history-migration.postgres.spec.ts
@@ -4,6 +4,7 @@ import { AgentHistoryWorkspaceStorageService } from 'src/engine/metadata-modules
import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
import { withWorkspaceContext } from 'src/engine/twenty-orm/storage/orm-workspace-context.storage';
import { AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { AgentChatQueueService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service';
import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { AgentHistoryTransactionService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-transaction.service';
import { AgentConversationWriterService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service';
@@ -230,8 +231,6 @@ const SCHEMA = getWorkspaceSchemaName(WORKSPACE_ID);
threads,
turns,
messageRepository,
- messageParts,
- {} as never,
{} as never,
chatSharing as never,
chatRecordEvents as never,
@@ -239,6 +238,16 @@ const SCHEMA = getWorkspaceSchemaName(WORKSPACE_ID);
chatThreadService,
);
+ const createQueueService = (messageRepository: typeof messages) =>
+ new AgentChatQueueService(
+ turns,
+ messageRepository,
+ messageParts,
+ {} as never,
+ conversationWriter,
+ chatThreadService,
+ );
+
const createActorService = (messageRepository: typeof messages) =>
new AgentChatActorService(
messageRepository,
@@ -791,6 +800,7 @@ const SCHEMA = getWorkspaceSchemaName(WORKSPACE_ID);
target: 'workspace',
});
const chat = createChatService(messages);
+ const queue = createQueueService(messages);
const actors = createActorService(messages);
const thread = await threads.insertAndReturnOne(WORKSPACE_ID, {
workspaceMemberId: MEMBER_ID,
@@ -807,14 +817,14 @@ const SCHEMA = getWorkspaceSchemaName(WORKSPACE_ID);
parts: [{ type: 'text', text: 'Live message after upgrade' }],
},
});
- const queued = await chat.queueMessage({
+ const queued = await queue.queueMessage({
workspaceMemberId: MEMBER_ID,
workspaceId: WORKSPACE_ID,
userWorkspaceId: OWNER_ID,
threadId: thread.id,
text: 'Queued after upgrade',
});
- await chat.promoteQueuedMessage({
+ await queue.promoteQueuedMessage({
workspaceId: WORKSPACE_ID,
threadId: thread.id,
messageId: queued.id,
diff --git a/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up-resolver.service.ts b/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up-resolver.service.ts
index 2a7da5d8231..489e8fb9ab0 100644
--- a/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up-resolver.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up-resolver.service.ts
@@ -87,7 +87,6 @@ export class PendingWakeUpResolverService {
event: readableEvent,
answer,
}),
- owner: ownerState.owner,
isOwnerGone: ownerState.status === 'GONE',
});
}
diff --git a/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up.service.ts b/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up.service.ts
index 6f8b05add6a..4ccdc3f8522 100644
--- a/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/pending-wake-up/services/pending-wake-up.service.ts
@@ -118,7 +118,7 @@ export class PendingWakeUpService {
{
...this.pendingWakeUpOwnerHandlerRegistryService
.getHandlerOrThrow(wakeUp.ownerType)
- .buildResumeJobOptions(wakeUp.ownerId),
+ .buildResumeJobOptions?.(wakeUp.ownerId),
delay: Math.max(delayMs, 0),
...(isDefined(deduplicationId)
? { deduplication: { id: deduplicationId } }
diff --git a/packages/twenty-server/src/engine/core-modules/pending-wake-up/types/pending-wake-up-owner-handler.type.ts b/packages/twenty-server/src/engine/core-modules/pending-wake-up/types/pending-wake-up-owner-handler.type.ts
index b032472e534..16d4d9f297f 100644
--- a/packages/twenty-server/src/engine/core-modules/pending-wake-up/types/pending-wake-up-owner-handler.type.ts
+++ b/packages/twenty-server/src/engine/core-modules/pending-wake-up/types/pending-wake-up-owner-handler.type.ts
@@ -6,7 +6,7 @@ import { type PendingWakeUpOwnerState } from 'src/engine/core-modules/pending-wa
import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config.type';
export type PendingWakeUpOwnerHandler<TOwner = unknown> = {
- buildResumeJobOptions(ownerId: string): QueueJobOptions;
+ buildResumeJobOptions?(ownerId: string): QueueJobOptions;
getOwnerState(
wakeUp: PendingWakeUpEntity,
@@ -24,7 +24,6 @@ export type PendingWakeUpOwnerHandler<TOwner = unknown> = {
resolve(input: {
wakeUp: PendingWakeUpEntity;
outcome: PendingWakeUpOutcome;
- owner: TOwner | null;
isOwnerGone: boolean;
}): Promise<void>;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/constants/agent-run-busy-retry-delay-ms.const.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/constants/agent-run-busy-retry-delay-ms.const.ts
deleted file mode 100644
index ff612b2aa32..00000000000
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/constants/agent-run-busy-retry-delay-ms.const.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-// a chat reply holding the conversation lasts seconds to minutes
-export const AGENT_RUN_BUSY_RETRY_DELAY_MS = 5_000;
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-pending-wake-up-handler.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-pending-wake-up-handler.service.ts
index a43a444ced6..035734e4e14 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-pending-wake-up-handler.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-pending-wake-up-handler.service.ts
@@ -1,6 +1,5 @@
import { Injectable, type OnModuleInit } from '@nestjs/common';
-import { type QueueJobOptions } from 'src/engine/core-modules/message-queue/drivers/interfaces/job-options.interface';
import { type PendingWakeUpEntity } from 'src/engine/core-modules/pending-wake-up/entities/pending-wake-up.entity';
import { PendingWakeUpOwnerHandlerRegistryService } from 'src/engine/core-modules/pending-wake-up/services/pending-wake-up-owner-handler-registry.service';
import { type PendingWakeUpOutcome } from 'src/engine/core-modules/pending-wake-up/types/pending-wake-up-outcome.type';
@@ -25,10 +24,6 @@ export class AgentRunPendingWakeUpHandlerService
this.pendingWakeUpOwnerHandlerRegistryService.register('AGENT_RUN', this);
}
- buildResumeJobOptions(): QueueJobOptions {
- return {};
- }
-
async getOwnerState({
workspaceId,
payload,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-runner.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-runner.service.ts
index c9bd2f85773..6bbcbf84ba7 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-runner.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-runner.service.ts
@@ -11,8 +11,6 @@ import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decora
import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
import { PendingWakeUpService } from 'src/engine/core-modules/pending-wake-up/services/pending-wake-up.service';
-import { RUN_AGENT_MAX_WAIT_MS } from 'src/engine/metadata-modules/ai/ai-agent-execution/constants/run-agent-max-wait-ms.const';
-import { AGENT_RUN_BUSY_RETRY_DELAY_MS } from 'src/engine/metadata-modules/ai/ai-agent-execution/constants/agent-run-busy-retry-delay-ms.const';
import { CONTINUE_AGENT_RUN_JOB_NAME } from 'src/engine/metadata-modules/ai/ai-agent-execution/constants/continue-agent-run-job-name.constant';
import { RUN_AGENT_JOB_NAME } from 'src/engine/metadata-modules/ai/ai-agent-execution/constants/run-agent-job-name.constant';
import { AGENT_WAIT_PROMPT } from 'src/engine/metadata-modules/ai/ai-agent-execution/pausing-tools/constants/agent-wait-prompt.constant';
@@ -35,6 +33,7 @@ import { type RunAgentJobData } from 'src/engine/metadata-modules/ai/ai-agent-ex
import { buildAgentRunSummary } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/build-agent-run-summary.util';
import { sumAgentRunSummaries } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/sum-agent-run-summaries.util';
import { AgentEntity } from 'src/engine/metadata-modules/ai/ai-agent/entities/agent.entity';
+import { AgentChatParkedRunsService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-parked-runs.service';
import { AgentChatEventPublisherService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-event-publisher.service';
import {
type AgentChatStreamClaim,
@@ -80,6 +79,7 @@ export class AgentRunnerService {
private readonly turnStreamService: AgentTurnStreamService,
private readonly streamRecoveryService: AgentChatStreamRecoveryService,
private readonly eventPublisherService: AgentChatEventPublisherService,
+ private readonly parkedRunsService: AgentChatParkedRunsService,
@InjectMessageQueue(MessageQueue.aiQueue)
private readonly messageQueueService: MessageQueueService,
@InjectWorkspaceScopedRepository(AgentEntity)
@@ -94,16 +94,30 @@ export class AgentRunnerService {
}
async runStarted(jobData: RunAgentJobData): Promise<void> {
- const { workspaceId, conversation, caller } = jobData;
+ const { workspaceId, conversation, caller, parkId } = jobData;
+
+ if (
+ !(await this.parkedRunsService.shouldRunParkedJob({
+ threadId: conversation.threadId,
+ parkId,
+ }))
+ ) {
+ return;
+ }
+
const handler = this.callerHandlerRegistry.getHandlerOrThrow(caller.type);
// a caller that stopped waiting while the run was queued, such as a stopped workflow, must not have it act
if ((await handler.getWaitingState({ workspaceId, caller })) === 'GONE') {
- await this.deliverFailure({
+ await this.agentRunSuspensionService.deliverOutcome({
workspaceId,
caller,
threadId: conversation.threadId,
- error: 'The caller stopped waiting before the run started',
+ outcome: {
+ status: 'FAILED',
+ error: 'The caller stopped waiting before the run started',
+ },
+ summary: null,
});
return;
@@ -116,15 +130,11 @@ export class AgentRunnerService {
}
if (result === CONVERSATION_BUSY) {
- if (await this.retryWhenFree({ jobName: RUN_AGENT_JOB_NAME, jobData })) {
- return;
- }
-
- await this.deliverFailure({
+ await this.parkedRunsService.park({
workspaceId,
- caller,
threadId: conversation.threadId,
- error: 'The conversation stayed busy',
+ jobName: RUN_AGENT_JOB_NAME,
+ jobData,
});
return;
@@ -191,11 +201,15 @@ export class AgentRunnerService {
error instanceof Error ? error.stack : error,
);
- await this.deliverFailure({
+ await this.agentRunSuspensionService.deliverOutcome({
workspaceId,
caller,
threadId: conversation.threadId,
- error: error instanceof Error ? error.message : String(error),
+ outcome: {
+ status: 'FAILED',
+ error: error instanceof Error ? error.message : String(error),
+ },
+ summary: null,
});
return null;
@@ -207,7 +221,14 @@ export class AgentRunnerService {
// died or failed midway finds it again, and a pause the run made again replaced it with another
// id, so each pause goes on once
async continue(jobData: ContinueAgentRunJobData): Promise<void> {
- const { workspaceId, threadId, wakeUpId, outcome } = jobData;
+ const { workspaceId, threadId, wakeUpId, outcome, parkId } = jobData;
+
+ if (
+ !(await this.parkedRunsService.shouldRunParkedJob({ threadId, parkId }))
+ ) {
+ return;
+ }
+
const wakeUp = await this.pendingWakeUpService.find({
workspaceId,
wakeUpId,
@@ -249,20 +270,12 @@ export class AgentRunnerService {
});
if (continued === CONVERSATION_BUSY) {
- if (
- !(await this.retryWhenFree({
- jobName: CONTINUE_AGENT_RUN_JOB_NAME,
- jobData,
- }))
- ) {
- await this.agentRunSuspensionService.settle({
- workspaceId,
- threadId,
- suspension,
- outcome: { status: 'FAILED', error: 'The conversation stayed busy' },
- isAwaitingAnswer: wakeUp.condition.type === 'ANSWER',
- });
- }
+ await this.parkedRunsService.park({
+ workspaceId,
+ threadId,
+ jobName: CONTINUE_AGENT_RUN_JOB_NAME,
+ jobData,
+ });
return;
}
@@ -329,49 +342,6 @@ export class AgentRunnerService {
});
}
- private async retryWhenFree<TJobData extends { busyAttempt?: number }>({
- jobName,
- jobData,
- }: {
- jobName: string;
- jobData: TJobData;
- }): Promise<boolean> {
- const busyAttempt = (jobData.busyAttempt ?? 0) + 1;
-
- // a run holding the conversation for longer than a runAgent call waits on it is taken as stuck
- if (busyAttempt * AGENT_RUN_BUSY_RETRY_DELAY_MS >= RUN_AGENT_MAX_WAIT_MS) {
- return false;
- }
-
- await this.messageQueueService.add<TJobData>(
- jobName,
- { ...jobData, busyAttempt },
- { delay: AGENT_RUN_BUSY_RETRY_DELAY_MS },
- );
-
- return true;
- }
-
- private async deliverFailure({
- workspaceId,
- caller,
- threadId,
- error,
- }: {
- workspaceId: string;
- caller: AgentRunCaller;
- threadId: string;
- error: string;
- }): Promise<void> {
- await this.agentRunSuspensionService.deliverOutcome({
- workspaceId,
- caller,
- threadId,
- outcome: { status: 'FAILED', error },
- summary: null,
- });
- }
-
private async continueSuspendedRun({
workspaceId,
threadId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/continue-agent-run-job-data.type.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/continue-agent-run-job-data.type.ts
index a4b32f3f455..197cc3da1ba 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/continue-agent-run-job-data.type.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/continue-agent-run-job-data.type.ts
@@ -6,5 +6,6 @@ export type ContinueAgentRunJobData = {
// the run's wake-up, which the continuation removes once the run went on, and what resolved it
wakeUpId: string;
outcome: AgentRunWakeUpOutcome;
- busyAttempt?: number;
+ // set on the delayed copy of a run parked behind a busy conversation
+ parkId?: string;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/run-agent-job-data.type.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/run-agent-job-data.type.ts
index caccc5cd1a6..2e03c52478a 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/run-agent-job-data.type.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/run-agent-job-data.type.ts
@@ -5,5 +5,5 @@ export type RunAgentJobData = Omit<
AgentRunnerRunInput,
'agent' | 'executionContext'
> & {
- busyAttempt?: number;
+ parkId?: string;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-stream-state.module.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-stream-state.module.ts
index af6b0762263..63f0280ebb0 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-stream-state.module.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-stream-state.module.ts
@@ -4,6 +4,7 @@ import { MetricsModule } from 'src/engine/core-modules/metrics/metrics.module';
import { AgentChatThreadModule } from 'src/engine/metadata-modules/ai/ai-chat/agent-chat-thread.module';
import { AgentChatCancelSubscriberService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-cancel-subscriber.service';
import { AgentChatEventPublisherService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-event-publisher.service';
+import { AgentChatParkedRunsService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-parked-runs.service';
import { AgentChatStreamHeartbeatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-heartbeat.service';
import { AgentChatStreamRecoveryService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-recovery.service';
import { AgentTurnStreamService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-turn-stream.service';
@@ -14,12 +15,14 @@ import { AgentHistoryModule } from 'src/engine/metadata-modules/ai/ai-history/ai
providers: [
AgentChatCancelSubscriberService,
AgentChatEventPublisherService,
+ AgentChatParkedRunsService,
AgentChatStreamHeartbeatService,
AgentChatStreamRecoveryService,
AgentTurnStreamService,
],
exports: [
AgentChatEventPublisherService,
+ AgentChatParkedRunsService,
AgentChatStreamHeartbeatService,
AgentChatStreamRecoveryService,
AgentTurnStreamService,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/ai-chat.module.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/ai-chat.module.ts
index f64a9f2ab5a..1fd53b01205 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/ai-chat.module.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/ai-chat.module.ts
@@ -39,6 +39,7 @@ import { WorkspaceSetupChatResolver } from 'src/engine/metadata-modules/ai/ai-ch
import { WorkspaceSetupChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/workspace-setup-chat.service';
import { AgentChatStreamingService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-streaming.service';
import { AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { AgentChatQueueService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service';
import { AgentChatThreadTargetService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-target.service';
import { AgentChatTurnPreflightService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-turn-preflight.service';
import { AgentTitleGenerationService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-title-generation.service';
@@ -80,6 +81,7 @@ import { SystemPromptBuilderService } from 'src/engine/metadata-modules/ai/ai-ch
WorkspaceSetupChatResolver,
AgentInboxResolver,
AgentInboxProposalService,
+ AgentChatQueueService,
AgentChatService,
AgentChatThreadTargetService,
AgentChatStreamingService,
@@ -96,6 +98,7 @@ import { SystemPromptBuilderService } from 'src/engine/metadata-modules/ai/ai-ch
exports: [
AgentChatThreadModule,
AgentChatActorService,
+ AgentChatQueueService,
AgentChatService,
AgentChatStreamingService,
AgentChatTurnPreflightService,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/constants/agent-chat-parked-run-fallback-delay-ms.constant.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/constants/agent-chat-parked-run-fallback-delay-ms.constant.ts
new file mode 100644
index 00000000000..6d42f996ebf
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/constants/agent-chat-parked-run-fallback-delay-ms.constant.ts
@@ -0,0 +1 @@
+export const AGENT_CHAT_PARKED_RUN_FALLBACK_DELAY_MS = 60_000;
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat-job.types.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat-job.types.ts
index a9905fae28b..4a74f8370ad 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat-job.types.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat-job.types.ts
@@ -12,8 +12,8 @@ export type StreamAgentChatJobData = {
modelId?: string;
lastUserMessageText: string;
hasTitle: boolean;
- existingTurnId?: string;
- // Absent only on jobs queued before sender attribution was deployed.
+ existingTurnId: string;
+ // absent on a turn that has no message of its own, such as a resume after an answer
messageId?: string;
conversationSizeTokens: number;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat.job.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat.job.ts
index 892d93902ef..e3e1abfca6e 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat.job.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat.job.ts
@@ -155,23 +155,14 @@ export class StreamAgentChatJob {
);
}
- const { message, sender, authorization } =
- await this.actorService.authorizeJob({
- workspaceId: data.workspaceId,
- threadId: data.threadId,
- messageId: data.messageId,
- turnId: data.existingTurnId,
- userWorkspaceId: data.userWorkspaceId,
- });
-
- const turnId = data.existingTurnId ?? message?.turnId;
-
- if (!isDefined(turnId)) {
- throw new AiException(
- 'Message turn not found',
- AiExceptionCode.MESSAGE_NOT_FOUND,
- );
- }
+ const turnId = data.existingTurnId;
+ const { sender, authorization } = await this.actorService.authorizeJob({
+ workspaceId: data.workspaceId,
+ threadId: data.threadId,
+ messageId: data.messageId,
+ turnId,
+ userWorkspaceId: data.userWorkspaceId,
+ });
const isRunning = await this.turnRecorderService.markRunning({
workspaceId: data.workspaceId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.ts
index 9f9c3152eb2..56adf9e56a2 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/__tests__/agent-chat.resolver.sharing.spec.ts
@@ -5,6 +5,7 @@ import {
import { AgentChatResolver } from 'src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver';
import { AgentChatThreadLifecycleService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service';
import { AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { AgentChatQueueService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service';
import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
import { AgentChatTurnPreflightService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-turn-preflight.service';
@@ -78,8 +79,6 @@ const buildResolver = () => {
{} as never,
messages as never,
{} as never,
- {} as never,
- {} as never,
sharing as never,
recordEvents as never,
{} as never,
@@ -115,8 +114,17 @@ const buildResolver = () => {
const messageReactions = {
findReactionsByMessageId: jest.fn().mockResolvedValue(new Map()),
};
+ const queueService = new AgentChatQueueService(
+ {} as never,
+ messages as never,
+ {} as never,
+ {} as never,
+ {} as never,
+ threadService,
+ );
const resolver = new AgentChatResolver(
chatService,
+ queueService,
threadService,
sharing as never,
streaming as never,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.ts
index a4455431d33..d99742dc605 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/resolvers/agent-chat.resolver.ts
@@ -1,3 +1,4 @@
+import { AgentChatQueueService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service';
import { AuthWorkspaceMemberId } from 'src/engine/decorators/auth/auth-workspace-member-id.decorator';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import { AgentChatThreadLifecycleService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service';
@@ -14,7 +15,7 @@ import {
import GraphQLJSON from 'graphql-type-json';
import { PermissionFlagType } from 'twenty-shared/constants';
-import { isDefined, isNonEmptyString } from 'twenty-shared/utils';
+import { isDefined } from 'twenty-shared/utils';
import { FeatureFlagKey } from 'twenty-shared/types';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
@@ -77,6 +78,7 @@ import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/service
export class AgentChatResolver {
constructor(
private readonly agentChatService: AgentChatService,
+ private readonly agentChatQueueService: AgentChatQueueService,
private readonly threadService: AgentChatThreadService,
private readonly sharingService: AgentChatSharingService,
private readonly agentChatStreamingService: AgentChatStreamingService,
@@ -314,31 +316,6 @@ export class AgentChatResolver {
return { messageId: savedMessage.messageId, queued: false };
}
- if (isNonEmptyString(thread.activeStreamId)) {
- const queuedMessage = await this.agentChatService.queueMessage({
- threadId,
- text,
- id: messageId,
- fileAttachments: fileAttachments ?? undefined,
- workspaceId: workspace.id,
- userWorkspaceId,
- workspaceMemberId,
- });
-
- await this.eventPublisherService.publish({
- threadId,
- workspaceId: workspace.id,
- event: { type: 'queue-updated' },
- });
-
- await this.agentChatStreamingService.flushNextQueuedMessage({
- threadId,
- workspaceId: workspace.id,
- });
-
- return { messageId: queuedMessage.id, queued: true };
- }
-
const result = await this.agentChatStreamingService.streamAgentChat({
thread,
browsingContext: browsingContext ?? null,
@@ -439,7 +416,7 @@ export class AgentChatResolver {
@AuthWorkspaceMemberId() workspaceMemberId: string,
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<boolean> {
- const message = await this.agentChatService.findQueuedMessage({
+ const message = await this.agentChatQueueService.findQueuedMessage({
messageId,
workspaceId: workspace.id,
});
@@ -456,7 +433,7 @@ export class AgentChatResolver {
workspaceMemberId,
workspaceId: workspace.id,
});
- const deleted = await this.agentChatService.deleteQueuedMessage({
+ const deleted = await this.agentChatQueueService.deleteQueuedMessage({
messageId,
workspaceId: workspace.id,
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.thread-contexts.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.thread-contexts.spec.ts
index d985ea52dcb..85d76284d0d 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.thread-contexts.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.thread-contexts.spec.ts
@@ -33,8 +33,6 @@ const buildService = () => {
{} as never,
{} as never,
{} as never,
- {} as never,
- {} as never,
);
return { service, threadRepository, messageRepository };
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-parked-runs.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-parked-runs.service.ts
new file mode 100644
index 00000000000..63744bf1257
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-parked-runs.service.ts
@@ -0,0 +1,136 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 } from 'uuid';
+
+import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
+import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
+import { RedisClientService } from 'src/engine/core-modules/redis-client/redis-client.service';
+import { AGENT_CHAT_PARKED_RUN_FALLBACK_DELAY_MS } from 'src/engine/metadata-modules/ai/ai-chat/constants/agent-chat-parked-run-fallback-delay-ms.constant';
+import { formatErrorWithCause } from 'src/engine/metadata-modules/ai/ai-chat/utils/format-error-with-cause.util';
+import { AgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/agent-history-repository';
+import { InjectAgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/inject-agent-history-repository.decorator';
+import { type AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
+
+type ParkedRun = {
+ jobName: string;
+ jobData: object;
+};
+
+// the delayed copy of each parked run covers a claim whose worker died, which nothing else releases
+@Injectable()
+export class AgentChatParkedRunsService {
+ private readonly logger = new Logger(AgentChatParkedRunsService.name);
+
+ constructor(
+ @InjectAgentHistoryRepository('agentChatThread')
+ private readonly threadRepository: AgentHistoryRepository<AgentChatThreadWorkspaceEntity>,
+ @InjectMessageQueue(MessageQueue.aiQueue)
+ private readonly messageQueueService: MessageQueueService,
+ private readonly redisClientService: RedisClientService,
+ ) {}
+
+ private getKey(threadId: string): string {
+ return `agent-chat-parked-runs:${threadId}`;
+ }
+
+ async park<TJobData extends { parkId?: string }>({
+ workspaceId,
+ threadId,
+ jobName,
+ jobData: { parkId: _previousParkId, ...jobData },
+ }: {
+ workspaceId: string;
+ threadId: string;
+ jobName: string;
+ jobData: TJobData;
+ }): Promise<void> {
+ const parkId = v4();
+ const parkedRun: ParkedRun = { jobName, jobData };
+
+ await this.redisClientService
+ .getClient()
+ .hset(this.getKey(threadId), parkId, JSON.stringify(parkedRun));
+
+ await this.messageQueueService.add<TJobData>(
+ jobName,
+ { ...jobData, parkId } as TJobData,
+ { delay: AGENT_CHAT_PARKED_RUN_FALLBACK_DELAY_MS },
+ );
+
+ // the conversation may have been released between the failed claim and the park
+ const thread = await this.threadRepository.findOne(workspaceId, {
+ where: { id: threadId },
+ select: ['id', 'activeStreamId'],
+ });
+
+ if (!isNonEmptyString(thread?.activeStreamId)) {
+ await this.wake({ workspaceId, threadId });
+ }
+ }
+
+ // whether the job goes on: the delayed copy of a parked run does only when nothing woke the run first
+ async shouldRunParkedJob({
+ threadId,
+ parkId,
+ }: {
+ threadId: string;
+ parkId?: string;
+ }): Promise<boolean> {
+ if (!isDefined(parkId)) {
+ return true;
+ }
+
+ const removedCount = await this.redisClientService
+ .getClient()
+ .hdel(this.getKey(threadId), parkId);
+
+ return removedCount === 1;
+ }
+
+ async wake({
+ workspaceId,
+ threadId,
+ }: {
+ workspaceId: string;
+ threadId: string;
+ }): Promise<void> {
+ const parkedRunsHashKey = this.getKey(threadId);
+ const results = await this.redisClientService
+ .getClient()
+ .multi()
+ .hgetall(parkedRunsHashKey)
+ .del(parkedRunsHashKey)
+ .exec()
+ .catch((error: unknown) => {
+ this.logger.error(
+ `Failed to read the runs parked on thread ${threadId} in workspace ${workspaceId}: ${formatErrorWithCause(error)}`,
+ );
+
+ return null;
+ });
+ const parkedRuns = (results?.[0]?.[1] ?? {}) as Record<string, string>;
+
+ for (const [parkId, parkedRun] of Object.entries(parkedRuns)) {
+ const { jobName, jobData } = JSON.parse(parkedRun) as ParkedRun;
+
+ try {
+ await this.messageQueueService.add(jobName, jobData);
+ } catch (error) {
+ this.logger.error(
+ `Failed to wake a run parked on thread ${threadId} in workspace ${workspaceId}: ${formatErrorWithCause(error)}`,
+ );
+ await this.redisClientService
+ .getClient()
+ .hset(parkedRunsHashKey, parkId, parkedRun)
+ .catch((reParkError: unknown) =>
+ this.logger.error(
+ `Failed to park again a run on thread ${threadId} in workspace ${workspaceId}, only its delayed copy will run it: ${formatErrorWithCause(reParkError)}`,
+ ),
+ );
+ }
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service.ts
new file mode 100644
index 00000000000..1f4aaf69cdb
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service.ts
@@ -0,0 +1,212 @@
+import { Injectable } from '@nestjs/common';
+
+import { FileFolder } from 'twenty-shared/types';
+import { isNonEmptyArray } from 'twenty-shared/utils';
+import { In, Like } from 'typeorm';
+
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
+import { type AiChatFileAttachment } from 'src/engine/metadata-modules/ai/ai-chat/types/ai-chat-file-attachment.type';
+import { resolveMessageSenderApplicationId } from 'src/engine/metadata-modules/ai/ai-chat/utils/resolve-message-sender-application-id.util';
+import { AgentMessageRole } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-role.enum';
+import { AgentMessageStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-status.enum';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/agent-history-repository';
+import { InjectAgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/inject-agent-history-repository.decorator';
+import { AgentConversationWriterService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service';
+import { AgentMessagePartWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message-part.workspace-entity';
+import { AgentMessageWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message.workspace-entity';
+import { AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
+
+@Injectable()
+export class AgentChatQueueService {
+ constructor(
+ @InjectAgentHistoryRepository('agentTurn')
+ private readonly turnRepository: AgentHistoryRepository<AgentTurnWorkspaceEntity>,
+ @InjectAgentHistoryRepository('agentMessage')
+ private readonly messageRepository: AgentHistoryRepository<AgentMessageWorkspaceEntity>,
+ @InjectAgentHistoryRepository('agentMessagePart')
+ private readonly messagePartRepository: AgentHistoryRepository<AgentMessagePartWorkspaceEntity>,
+ @InjectWorkspaceScopedRepository(FileEntity)
+ private readonly fileRepository: WorkspaceScopedRepository<FileEntity>,
+ private readonly conversationWriterService: AgentConversationWriterService,
+ private readonly threadService: AgentChatThreadService,
+ ) {}
+
+ async queueMessage({
+ threadId,
+ text,
+ id,
+ fileAttachments,
+ workspaceId,
+ userWorkspaceId,
+ workspaceMemberId,
+ }: {
+ threadId: string;
+ text: string;
+ id?: string;
+ fileAttachments?: AiChatFileAttachment[];
+ workspaceId: string;
+ userWorkspaceId: string;
+ workspaceMemberId: string;
+ }) {
+ const messageValues = {
+ ...(id ? { id } : {}),
+ threadId,
+ turnId: null,
+ role: AgentMessageRole.USER,
+ agentId: null,
+ status: AgentMessageStatus.QUEUED,
+ senderWorkspaceMemberId: workspaceMemberId,
+ senderApplicationId: resolveMessageSenderApplicationId({
+ workspaceId,
+ userWorkspaceId,
+ }),
+ };
+
+ const insertResult = await this.messageRepository.insert(
+ workspaceId,
+ messageValues,
+ );
+
+ const savedMessageId = (id ?? insertResult.identifiers[0].id) as string;
+
+ const validFiles = isNonEmptyArray(fileAttachments)
+ ? await this.fileRepository.find(workspaceId, {
+ where: {
+ id: In(fileAttachments.map((attachment) => attachment.id)),
+ path: Like(`${FileFolder.AgentChat}/%`),
+ },
+ select: ['id'],
+ })
+ : [];
+
+ const validFileIds = new Set(validFiles.map((file) => file.id));
+
+ const parts = [
+ {
+ messageId: savedMessageId,
+ orderIndex: 0,
+ type: 'text',
+ textContent: text,
+ },
+ ...(fileAttachments ?? [])
+ .filter((attachment) => validFileIds.has(attachment.id))
+ .map((attachment, index) => ({
+ messageId: savedMessageId,
+ orderIndex: index + 1,
+ type: 'file',
+ fileId: attachment.id,
+ fileFilename: attachment.filename,
+ })),
+ ];
+
+ await this.messagePartRepository.insert(workspaceId, parts);
+
+ await this.threadService.notifyThreadActivityUpdated({
+ threadId,
+ workspaceMemberId,
+ workspaceId,
+ text,
+ });
+
+ return {
+ id: savedMessageId,
+ ...messageValues,
+ };
+ }
+
+ async hasQueuedMessages({
+ threadId,
+ workspaceId,
+ }: {
+ threadId: string;
+ workspaceId: string;
+ }): Promise<boolean> {
+ return this.messageRepository.existsBy(workspaceId, {
+ threadId,
+ status: AgentMessageStatus.QUEUED,
+ });
+ }
+
+ async getQueuedMessages({
+ threadId,
+ workspaceId,
+ }: {
+ threadId: string;
+ workspaceId: string;
+ }): Promise<AgentMessageWorkspaceEntity[]> {
+ return this.messageRepository.find(workspaceId, {
+ where: {
+ threadId,
+ status: AgentMessageStatus.QUEUED,
+ },
+ order: { createdAt: 'ASC' },
+ relations: ['parts', 'parts.file'],
+ });
+ }
+
+ async findQueuedMessage({
+ messageId,
+ workspaceId,
+ }: {
+ messageId: string;
+ workspaceId: string;
+ }): Promise<AgentMessageWorkspaceEntity | null> {
+ return this.messageRepository.findOne(workspaceId, {
+ where: { id: messageId, status: AgentMessageStatus.QUEUED },
+ });
+ }
+
+ async deleteQueuedMessage({
+ messageId,
+ workspaceId,
+ }: {
+ messageId: string;
+ workspaceId: string;
+ }): Promise<boolean> {
+ const result = await this.messageRepository.delete(workspaceId, {
+ id: messageId,
+ status: AgentMessageStatus.QUEUED,
+ });
+
+ return (result.affected ?? 0) > 0;
+ }
+
+ async promoteQueuedMessage({
+ messageId,
+ threadId,
+ workspaceId,
+ }: {
+ messageId: string;
+ threadId: string;
+ workspaceId: string;
+ }): Promise<string | null> {
+ const savedTurnId = await this.conversationWriterService.insertTurn({
+ workspaceId,
+ threadId,
+ agentId: null,
+ status: AgentTurnStatus.RUNNING,
+ });
+
+ const result = await this.messageRepository.update(
+ workspaceId,
+ { id: messageId, threadId, status: AgentMessageStatus.QUEUED },
+ {
+ status: AgentMessageStatus.SENT,
+ processedAt: new Date().toISOString(),
+ turnId: savedTurnId,
+ },
+ );
+
+ if ((result.affected ?? 0) === 0) {
+ await this.turnRepository.delete(workspaceId, { id: savedTurnId });
+
+ return null;
+ }
+
+ return savedTurnId;
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-recovery.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-recovery.service.ts
index 1a8bcb44212..ab7a0328498 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-recovery.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-recovery.service.ts
@@ -13,6 +13,7 @@ import { AgentMessageStatus } from 'src/engine/metadata-modules/ai/ai-history/en
import { FLUSH_QUEUED_AGENT_CHAT_MESSAGES_JOB_NAME } from 'src/engine/metadata-modules/ai/ai-chat/jobs/flush-queued-agent-chat-messages-job-name.constant';
import { type FlushQueuedAgentChatMessagesJobData } from 'src/engine/metadata-modules/ai/ai-chat/jobs/flush-queued-agent-chat-messages-job.types';
import { AgentChatEventPublisherService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-event-publisher.service';
+import { AgentChatParkedRunsService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-parked-runs.service';
import { AgentChatStreamHeartbeatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-heartbeat.service';
import { formatErrorWithCause } from 'src/engine/metadata-modules/ai/ai-chat/utils/format-error-with-cause.util';
import { type StreamErrorPayload } from 'src/engine/metadata-modules/ai/ai-history/utils/map-error-to-stream-error.util';
@@ -41,6 +42,7 @@ export class AgentChatStreamRecoveryService {
@InjectMessageQueue(MessageQueue.aiStreamQueue)
private readonly chatMessageQueueService: MessageQueueService,
private readonly streamHeartbeatService: AgentChatStreamHeartbeatService,
+ private readonly parkedRunsService: AgentChatParkedRunsService,
private readonly eventPublisherService: AgentChatEventPublisherService,
private readonly metricsService: MetricsService,
private readonly turnRecorderService: AgentTurnRecorderService,
@@ -96,6 +98,8 @@ export class AgentChatStreamRecoveryService {
await this.flushQueuedMessages({ threadId, workspaceId });
}
+ await this.parkedRunsService.wake({ workspaceId, threadId });
+
return true;
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-streaming.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-streaming.service.ts
index f5f291918b4..0911bcaec1e 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-streaming.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-streaming.service.ts
@@ -1,4 +1,5 @@
import { isNonEmptyString } from '@sniptt/guards';
+import { AgentChatQueueService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service';
import { AuthException } from 'src/engine/core-modules/auth/auth.exception';
import { PermissionsException } from 'src/engine/metadata-modules/permissions/permissions.exception';
import { AgentChatActorService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-actor.service';
@@ -82,6 +83,7 @@ export class AgentChatStreamingService {
@InjectMessageQueue(MessageQueue.aiStreamQueue)
private readonly messageQueueService: MessageQueueService,
private readonly agentChatService: AgentChatService,
+ private readonly agentChatQueueService: AgentChatQueueService,
private readonly threadService: AgentChatThreadService,
private readonly eventPublisherService: AgentChatEventPublisherService,
private readonly conversationReaderService: AgentConversationReaderService,
@@ -118,7 +120,7 @@ export class AgentChatStreamingService {
workspaceId,
threadId,
}),
- this.agentChatService.hasQueuedMessages({ threadId, workspaceId }),
+ this.agentChatQueueService.hasQueuedMessages({ threadId, workspaceId }),
]);
await this.settlePendingToolCallsBeforeSending({
@@ -139,7 +141,7 @@ export class AgentChatStreamingService {
}));
if (!claimed) {
- const queuedMessage = await this.agentChatService.queueMessage({
+ const queuedMessage = await this.agentChatQueueService.queueMessage({
threadId,
text,
id: messageId,
@@ -512,15 +514,20 @@ export class AgentChatStreamingService {
}): Promise<void> {
const threadStatus = await this.threadRepository.findOne(workspaceId, {
where: { id: threadId },
- select: ['id', 'deletedAt', 'pendingQuestionMessageId'],
+ select: ['id', 'deletedAt', 'pendingQuestionMessageId', 'activeStreamId'],
});
- if (!threadStatus || threadStatus.deletedAt) {
+ // the stream flushes the queue when it lets go, so a send behind it reads nothing more
+ if (
+ !threadStatus ||
+ threadStatus.deletedAt ||
+ isNonEmptyString(threadStatus.activeStreamId)
+ ) {
return;
}
const [queuedMessages, { suspendedRun }] = await Promise.all([
- this.agentChatService.getQueuedMessages({ threadId, workspaceId }),
+ this.agentChatQueueService.getQueuedMessages({ threadId, workspaceId }),
this.agentRunSuspensionService.findConversationWait({
workspaceId,
threadId,
@@ -582,7 +589,7 @@ export class AgentChatStreamingService {
) {
throw error;
}
- await this.agentChatService.deleteQueuedMessage({
+ await this.agentChatQueueService.deleteQueuedMessage({
messageId: candidate.id,
workspaceId,
});
@@ -608,7 +615,7 @@ export class AgentChatStreamingService {
);
if (messageText === '' && !hasFileAttachment) {
- await this.agentChatService.deleteQueuedMessage({
+ await this.agentChatQueueService.deleteQueuedMessage({
messageId: nextQueued.id,
workspaceId,
});
@@ -631,7 +638,7 @@ export class AgentChatStreamingService {
await this.releaseClaimOnEnqueueFailure(
{ threadId, workspaceId, streamId },
async () => {
- const turnId = await this.agentChatService.promoteQueuedMessage({
+ const turnId = await this.agentChatQueueService.promoteQueuedMessage({
messageId: nextQueued.id,
threadId,
workspaceId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.ts
index dbe26f94681..aa08b1f4f72 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service.ts
@@ -4,7 +4,7 @@ import { AgentChatSharingService } from 'src/engine/metadata-modules/ai/ai-chat/
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 { Injectable } from '@nestjs/common';
-import { type ActorMetadata, FileFolder } from 'twenty-shared/types';
+import { type ActorMetadata } from 'twenty-shared/types';
import { ExtendedUIMessage } from 'twenty-shared/ai';
import {
@@ -12,23 +12,16 @@ import {
isNonEmptyArray,
isNonEmptyString,
} from 'twenty-shared/utils';
-import { In, Like, Not } from 'typeorm';
+import { In, Not } from 'typeorm';
-import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
-import { AgentMessagePartWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message-part.workspace-entity';
import { AgentMessageRole } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-role.enum';
-import { AgentMessageStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-status.enum';
import { AgentMessageWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message.workspace-entity';
import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
-import { buildEndWaitingAgentTurnQuery } from 'src/engine/metadata-modules/ai/ai-history/utils/build-end-waiting-agent-turn-query.util';
import { buildActorMetadataFromAuthContext } from 'src/engine/core-modules/actor/utils/build-actor-metadata-from-auth-context.util';
import { AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity';
-import { findAwaitingPausingTool } from 'src/engine/metadata-modules/ai/ai-agent-execution/pausing-tools/utils/find-awaiting-pausing-tool.util';
import { AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
-import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
-import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
-import { AiChatFileAttachment } from 'src/engine/metadata-modules/ai/ai-chat/types/ai-chat-file-attachment.type';
import { AgentChatThreadRecordEventService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-record-event.service';
+import { resolveMessageSenderApplicationId } from 'src/engine/metadata-modules/ai/ai-chat/utils/resolve-message-sender-application-id.util';
import { AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { AgentConversationWriterService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service';
import { AgentTitleGenerationService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-title-generation.service';
@@ -43,10 +36,6 @@ export class AgentChatService {
private readonly turnRepository: AgentHistoryRepository<AgentTurnWorkspaceEntity>,
@InjectAgentHistoryRepository('agentMessage')
private readonly messageRepository: AgentHistoryRepository<AgentMessageWorkspaceEntity>,
- @InjectAgentHistoryRepository('agentMessagePart')
- private readonly messagePartRepository: AgentHistoryRepository<AgentMessagePartWorkspaceEntity>,
- @InjectWorkspaceScopedRepository(FileEntity)
- private readonly fileRepository: WorkspaceScopedRepository<FileEntity>,
private readonly titleGenerationService: AgentTitleGenerationService,
private readonly sharingService: AgentChatSharingService,
private readonly threadRecordEventService: AgentChatThreadRecordEventService,
@@ -61,17 +50,12 @@ export class AgentChatService {
workspaceId: string;
userWorkspaceId?: string;
}) {
- const context = workspaceAuthContextStorage.getStore();
- const applicationId =
- isDefined(context) &&
- isUserAuthContext(context) &&
- context.workspace.id === workspaceId &&
- context.userWorkspaceId === userWorkspaceId
- ? context.application?.id
- : undefined;
return {
senderUserWorkspaceId: userWorkspaceId ?? null,
- senderApplicationId: applicationId ?? null,
+ senderApplicationId: resolveMessageSenderApplicationId({
+ workspaceId,
+ userWorkspaceId,
+ }),
};
}
@@ -96,8 +80,6 @@ export class AgentChatService {
async addMessage({
threadId,
uiMessage,
- agentId,
- turnId,
turnStatus = AgentTurnStatus.RUNNING,
id,
workspaceId,
@@ -105,22 +87,18 @@ export class AgentChatService {
}: {
threadId: string;
uiMessage: Omit<ExtendedUIMessage, 'id'>;
- agentId?: string;
- turnId?: string;
turnStatus?: AgentTurnStatus;
id?: string;
workspaceId: string;
userWorkspaceId?: string;
}) {
- const actualTurnId =
- turnId ??
- (await this.conversationWriterService.insertTurn({
- workspaceId,
- threadId,
- agentId: agentId ?? null,
- status: turnStatus,
- createdBy: this.getMessageSenderActor({ workspaceId, userWorkspaceId }),
- }));
+ const turnId = await this.conversationWriterService.insertTurn({
+ workspaceId,
+ threadId,
+ agentId: null,
+ status: turnStatus,
+ createdBy: this.getMessageSenderActor({ workspaceId, userWorkspaceId }),
+ });
const senderValues = this.getMessageSenderValues({
workspaceId,
@@ -132,9 +110,9 @@ export class AgentChatService {
workspaceId,
id,
threadId,
- turnId: actualTurnId,
+ turnId,
role: uiMessage.role as AgentMessageRole,
- agentId: agentId ?? null,
+ agentId: null,
...senderValues,
processedAt,
parts: uiMessage.parts ?? [],
@@ -143,9 +121,9 @@ export class AgentChatService {
return {
id: savedMessageId,
threadId,
- turnId: actualTurnId,
+ turnId,
role: uiMessage.role as AgentMessageRole,
- agentId: agentId ?? null,
+ agentId: null,
processedAt: processedAt.toISOString(),
...senderValues,
};
@@ -279,282 +257,6 @@ export class AgentChatService {
});
}
- async queueMessage({
- threadId,
- text,
- id,
- fileAttachments,
- workspaceId,
- userWorkspaceId,
- workspaceMemberId,
- }: {
- threadId: string;
- text: string;
- id?: string;
- fileAttachments?: AiChatFileAttachment[];
- workspaceId: string;
- userWorkspaceId: string;
- workspaceMemberId: string;
- }) {
- const messageValues = {
- ...(id ? { id } : {}),
- threadId,
- turnId: null,
- role: AgentMessageRole.USER,
- agentId: null,
- status: AgentMessageStatus.QUEUED,
- senderWorkspaceMemberId: workspaceMemberId,
- senderApplicationId: this.getMessageSenderValues({
- workspaceId,
- userWorkspaceId,
- }).senderApplicationId,
- };
-
- const insertResult = await this.messageRepository.insert(
- workspaceId,
- messageValues,
- );
-
- const savedMessageId = (id ?? insertResult.identifiers[0].id) as string;
-
- const validFiles =
- fileAttachments && fileAttachments.length > 0
- ? await this.fileRepository.find(workspaceId, {
- where: {
- id: In(fileAttachments.map((attachment) => attachment.id)),
- path: Like(`${FileFolder.AgentChat}/%`),
- },
- select: ['id'],
- })
- : [];
-
- const validFileIds = new Set(validFiles.map((file) => file.id));
-
- const parts = [
- {
- messageId: savedMessageId,
- orderIndex: 0,
- type: 'text',
- textContent: text,
- },
- ...(fileAttachments ?? [])
- .filter((attachment) => validFileIds.has(attachment.id))
- .map((attachment, index) => ({
- messageId: savedMessageId,
- orderIndex: index + 1,
- type: 'file',
- fileId: attachment.id,
- fileFilename: attachment.filename,
- })),
- ];
-
- await this.messagePartRepository.insert(workspaceId, parts);
-
- await this.threadService.notifyThreadActivityUpdated({
- threadId,
- workspaceMemberId,
- workspaceId,
- text,
- });
-
- return {
- id: savedMessageId,
- ...messageValues,
- };
- }
-
- async hasQueuedMessages({
- threadId,
- workspaceId,
- }: {
- threadId: string;
- workspaceId: string;
- }): Promise<boolean> {
- return this.messageRepository.existsBy(workspaceId, {
- threadId,
- status: AgentMessageStatus.QUEUED,
- });
- }
-
- async getQueuedMessages({
- threadId,
- workspaceId,
- }: {
- threadId: string;
- workspaceId: string;
- }): Promise<AgentMessageWorkspaceEntity[]> {
- return this.messageRepository.find(workspaceId, {
- where: {
- threadId,
- status: AgentMessageStatus.QUEUED,
- },
- order: { createdAt: 'ASC' },
- relations: ['parts', 'parts.file'],
- });
- }
-
- async findQueuedMessage({
- messageId,
- workspaceId,
- }: {
- messageId: string;
- workspaceId: string;
- }): Promise<AgentMessageWorkspaceEntity | null> {
- return this.messageRepository.findOne(workspaceId, {
- where: { id: messageId, status: AgentMessageStatus.QUEUED },
- });
- }
-
- async deleteQueuedMessage({
- messageId,
- workspaceId,
- }: {
- messageId: string;
- workspaceId: string;
- }): Promise<boolean> {
- const result = await this.messageRepository.delete(workspaceId, {
- id: messageId,
- status: AgentMessageStatus.QUEUED,
- });
-
- return (result.affected ?? 0) > 0;
- }
-
- async promoteQueuedMessage({
- messageId,
- threadId,
- workspaceId,
- }: {
- messageId: string;
- threadId: string;
- workspaceId: string;
- }): Promise<string | null> {
- const savedTurnId = await this.conversationWriterService.insertTurn({
- workspaceId,
- threadId,
- agentId: null,
- status: AgentTurnStatus.RUNNING,
- });
-
- const result = await this.messageRepository.update(
- workspaceId,
- { id: messageId, threadId, status: AgentMessageStatus.QUEUED },
- {
- status: AgentMessageStatus.SENT,
- processedAt: new Date().toISOString(),
- turnId: savedTurnId,
- },
- );
-
- if ((result.affected ?? 0) === 0) {
- await this.turnRepository.delete(workspaceId, { id: savedTurnId });
-
- return null;
- }
-
- return savedTurnId;
- }
-
- async findAwaitingToolParts({
- messageId,
- workspaceId,
- }: {
- messageId: string;
- workspaceId: string;
- }): Promise<
- Pick<AgentMessagePartWorkspaceEntity, 'id' | 'toolName' | 'toolOutput'>[]
- > {
- const parts = await this.messagePartRepository.find(workspaceId, {
- where: { messageId },
- select: ['id', 'toolName', 'toolOutput'],
- });
-
- return parts.filter((part) => isDefined(findAwaitingPausingTool(part)));
- }
-
- // only a call still pending is claimed, so two answers can never both run it; the rest of the
- // pending output, such as the workflow step waiting on it, is kept
- async claimToolCallAnswer({
- partId,
- toolOutput,
- workspaceId,
- }: {
- partId: string;
- toolOutput: Record<string, unknown>;
- workspaceId: string;
- }): Promise<boolean> {
- const claimedParts = await this.messagePartRepository.query(
- workspaceId,
- ({ manager, table }) =>
- manager.query<{ id: string }[]>(
- `WITH claimed_part AS (UPDATE ${table('agentMessagePart')} SET "toolOutput" = "toolOutput" || $2::jsonb, "updatedAt" = now()
- WHERE id = $1 AND "toolOutput"->'result'->>'status' = 'pending' RETURNING id) SELECT id FROM claimed_part`,
- [partId, JSON.stringify(toolOutput)],
- ),
- );
-
- return claimedParts.length === 1;
- }
-
- // written together so an answer never strands a conversation waiting on answered calls
- async recordToolCallAnswer({
- threadId,
- messageId,
- partId,
- toolOutput,
- isLastAnswer,
- workspaceId,
- }: {
- threadId: string;
- messageId: string;
- partId: string;
- toolOutput: Record<string, unknown>;
- isLastAnswer: boolean;
- workspaceId: string;
- }): Promise<void> {
- const isPendingQuestionCleared = await this.messagePartRepository.query(
- workspaceId,
- async ({ manager, table }) => {
- await manager.query(
- `UPDATE ${table('agentMessagePart')} SET "toolOutput" = $2::jsonb, "updatedAt" = now() WHERE id = $1`,
- [partId, JSON.stringify(toolOutput)],
- );
-
- if (!isLastAnswer) {
- return false;
- }
-
- const clearedThreads = await manager.query<{ id: string }[]>(
- `WITH cleared AS (
- UPDATE ${table('agentChatThread')} SET "pendingQuestionMessageId" = NULL, "updatedAt" = now()
- WHERE id = $1 AND "pendingQuestionMessageId" = $2
- RETURNING id
- ) SELECT id FROM cleared`,
- [threadId, messageId],
- );
-
- if (clearedThreads.length === 0) {
- return false;
- }
-
- await manager.query(buildEndWaitingAgentTurnQuery({ table }), [
- messageId,
- AgentTurnStatus.COMPLETED,
- ]);
-
- return true;
- },
- );
-
- if (isPendingQuestionCleared) {
- await this.threadRecordEventService.emitPendingQuestionCleared({
- workspaceId,
- threadId,
- messageId,
- });
- }
- }
-
async restoreThread({
threadId,
workspaceMemberId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/resolve-message-sender-application-id.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/resolve-message-sender-application-id.util.ts
new file mode 100644
index 00000000000..c05b9bdab62
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/resolve-message-sender-application-id.util.ts
@@ -0,0 +1,27 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
+import { workspaceAuthContextStorage } from 'src/engine/core-modules/auth/storage/workspace-auth-context.storage';
+
+export const resolveMessageSenderApplicationId = ({
+ workspaceId,
+ userWorkspaceId,
+}: {
+ workspaceId: string;
+ userWorkspaceId?: string;
+}): string | null => {
+ const context = workspaceAuthContextStorage.getStore();
+
+ if (!isDefined(context) || !isUserAuthContext(context)) {
+ return null;
+ }
+
+ if (
+ context.workspace.id !== workspaceId ||
+ context.userWorkspaceId !== userWorkspaceId
+ ) {
+ return null;
+ }
+
+ return context.application?.id ?? null;
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/ai-tool-call-answer.module.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/ai-tool-call-answer.module.ts
index dff81c823be..656120250c2 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/ai-tool-call-answer.module.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/ai-tool-call-answer.module.ts
@@ -8,6 +8,7 @@ import { AgentChatStreamStateModule } from 'src/engine/metadata-modules/ai/ai-ch
import { AiChatModule } from 'src/engine/metadata-modules/ai/ai-chat/ai-chat.module';
import { AgentHistoryModule } from 'src/engine/metadata-modules/ai/ai-history/ai-history.module';
import { ToolCallAnswerResolver } from 'src/engine/metadata-modules/ai/ai-tool-call-answer/resolvers/tool-call-answer.resolver';
+import { ToolCallAnswerRecorderService } from 'src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service';
import { ToolCallAnswerService } from 'src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer.service';
import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
@@ -23,6 +24,10 @@ import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permi
PermissionsModule,
ToolProviderModule,
],
- providers: [ToolCallAnswerService, ToolCallAnswerResolver],
+ providers: [
+ ToolCallAnswerService,
+ ToolCallAnswerRecorderService,
+ ToolCallAnswerResolver,
+ ],
})
export class AiToolCallAnswerModule {}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.record-tool-call-answer.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/__tests__/tool-call-answer-recorder.service.spec.ts
similarity index 86%
rename from packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.record-tool-call-answer.spec.ts
rename to packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/__tests__/tool-call-answer-recorder.service.spec.ts
index e49b2ee159d..7f2460cc791 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.record-tool-call-answer.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/__tests__/tool-call-answer-recorder.service.spec.ts
@@ -1,4 +1,4 @@
-import { AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { ToolCallAnswerRecorderService } from 'src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service';
const buildService = () => {
const threadRecordEventService = {
@@ -16,23 +16,15 @@ const buildService = () => {
}),
);
- const service = new AgentChatService(
- {} as never,
- {} as never,
- {} as never,
+ const service = new ToolCallAnswerRecorderService(
messagePartRepository as never,
- {} as never,
- {} as never,
- {} as never,
threadRecordEventService as never,
- {} as never,
- {} as never,
);
return { service, messagePartRepository, threadRecordEventService };
};
-describe('AgentChatService recordToolCallAnswer', () => {
+describe('ToolCallAnswerRecorderService recordToolCallAnswer', () => {
const answerArguments = {
threadId: 'thread-id',
messageId: 'question-message-id',
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service.ts
new file mode 100644
index 00000000000..6b3c2c1949e
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service.ts
@@ -0,0 +1,119 @@
+import { Injectable } from '@nestjs/common';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { findAwaitingPausingTool } from 'src/engine/metadata-modules/ai/ai-agent-execution/pausing-tools/utils/find-awaiting-pausing-tool.util';
+import { AgentChatThreadRecordEventService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-record-event.service';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/agent-history-repository';
+import { InjectAgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/inject-agent-history-repository.decorator';
+import { AgentMessagePartWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message-part.workspace-entity';
+import { buildEndWaitingAgentTurnQuery } from 'src/engine/metadata-modules/ai/ai-history/utils/build-end-waiting-agent-turn-query.util';
+
+@Injectable()
+export class ToolCallAnswerRecorderService {
+ constructor(
+ @InjectAgentHistoryRepository('agentMessagePart')
+ private readonly messagePartRepository: AgentHistoryRepository<AgentMessagePartWorkspaceEntity>,
+ private readonly threadRecordEventService: AgentChatThreadRecordEventService,
+ ) {}
+
+ async findAwaitingToolParts({
+ messageId,
+ workspaceId,
+ }: {
+ messageId: string;
+ workspaceId: string;
+ }): Promise<
+ Pick<AgentMessagePartWorkspaceEntity, 'id' | 'toolName' | 'toolOutput'>[]
+ > {
+ const parts = await this.messagePartRepository.find(workspaceId, {
+ where: { messageId },
+ select: ['id', 'toolName', 'toolOutput'],
+ });
+
+ return parts.filter((part) => isDefined(findAwaitingPausingTool(part)));
+ }
+
+ // only a still-pending call is claimed, so two answers never both run it
+ async claimToolCallAnswer({
+ partId,
+ toolOutput,
+ workspaceId,
+ }: {
+ partId: string;
+ toolOutput: Record<string, unknown>;
+ workspaceId: string;
+ }): Promise<boolean> {
+ const claimedParts = await this.messagePartRepository.query(
+ workspaceId,
+ ({ manager, table }) =>
+ manager.query<{ id: string }[]>(
+ `WITH claimed_part AS (UPDATE ${table('agentMessagePart')} SET "toolOutput" = "toolOutput" || $2::jsonb, "updatedAt" = now()
+ WHERE id = $1 AND "toolOutput"->'result'->>'status' = 'pending' RETURNING id) SELECT id FROM claimed_part`,
+ [partId, JSON.stringify(toolOutput)],
+ ),
+ );
+
+ return claimedParts.length === 1;
+ }
+
+ // written together so an answer never strands a conversation waiting on answered calls
+ async recordToolCallAnswer({
+ threadId,
+ messageId,
+ partId,
+ toolOutput,
+ isLastAnswer,
+ workspaceId,
+ }: {
+ threadId: string;
+ messageId: string;
+ partId: string;
+ toolOutput: Record<string, unknown>;
+ isLastAnswer: boolean;
+ workspaceId: string;
+ }): Promise<void> {
+ const isPendingQuestionCleared = await this.messagePartRepository.query(
+ workspaceId,
+ async ({ manager, table }) => {
+ await manager.query(
+ `UPDATE ${table('agentMessagePart')} SET "toolOutput" = $2::jsonb, "updatedAt" = now() WHERE id = $1`,
+ [partId, JSON.stringify(toolOutput)],
+ );
+
+ if (!isLastAnswer) {
+ return false;
+ }
+
+ const clearedThreads = await manager.query<{ id: string }[]>(
+ `WITH cleared AS (
+ UPDATE ${table('agentChatThread')} SET "pendingQuestionMessageId" = NULL, "updatedAt" = now()
+ WHERE id = $1 AND "pendingQuestionMessageId" = $2
+ RETURNING id
+ ) SELECT id FROM cleared`,
+ [threadId, messageId],
+ );
+
+ if (clearedThreads.length === 0) {
+ return false;
+ }
+
+ await manager.query(buildEndWaitingAgentTurnQuery({ table }), [
+ messageId,
+ AgentTurnStatus.COMPLETED,
+ ]);
+
+ return true;
+ },
+ );
+
+ if (isPendingQuestionCleared) {
+ await this.threadRecordEventService.emitPendingQuestionCleared({
+ workspaceId,
+ threadId,
+ messageId,
+ });
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer.service.ts
index b0570120f49..8c7e720c5a7 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer.service.ts
@@ -5,6 +5,7 @@ import { generateId } from 'ai';
import { PermissionFlagType } from 'twenty-shared/constants';
import { isDefined } from 'twenty-shared/utils';
+import { ToolCallAnswerRecorderService } from 'src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service';
import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
import { workspaceAuthContextStorage } from 'src/engine/core-modules/auth/storage/workspace-auth-context.storage';
import { type PendingWakeUpEntity } from 'src/engine/core-modules/pending-wake-up/entities/pending-wake-up.entity';
@@ -65,6 +66,7 @@ export class ToolCallAnswerService {
@InjectAgentHistoryRepository('agentChatThread')
private readonly threadRepository: AgentHistoryRepository<AgentChatThreadWorkspaceEntity>,
private readonly agentChatService: AgentChatService,
+ private readonly toolCallAnswerRecorderService: ToolCallAnswerRecorderService,
private readonly agentChatStreamingService: AgentChatStreamingService,
private readonly streamRecoveryService: AgentChatStreamRecoveryService,
private readonly threadService: AgentChatThreadService,
@@ -170,7 +172,7 @@ export class ToolCallAnswerService {
try {
const awaitingToolParts =
- await this.agentChatService.findAwaitingToolParts({
+ await this.toolCallAnswerRecorderService.findAwaitingToolParts({
messageId: toolPart.messageId,
workspaceId,
});
@@ -219,7 +221,7 @@ export class ToolCallAnswerService {
if (isDefined(runningToolResult)) {
if (
- !(await this.agentChatService.claimToolCallAnswer({
+ !(await this.toolCallAnswerRecorderService.claimToolCallAnswer({
partId: toolPart.id,
toolOutput: runningToolResult,
workspaceId,
@@ -242,7 +244,7 @@ export class ToolCallAnswerService {
isLastAnswer = awaitingToolParts.length === 1;
- await this.agentChatService.recordToolCallAnswer({
+ await this.toolCallAnswerRecorderService.recordToolCallAnswer({
threadId,
messageId: toolPart.messageId,
partId: toolPart.id,
diff --git a/packages/twenty-server/test/integration/ai/suites/agent-chat-stream-state.integration-spec.ts b/packages/twenty-server/test/integration/ai/suites/agent-chat-stream-state.integration-spec.ts
index 8e47fefef40..d0de6e5963d 100644
--- a/packages/twenty-server/test/integration/ai/suites/agent-chat-stream-state.integration-spec.ts
+++ b/packages/twenty-server/test/integration/ai/suites/agent-chat-stream-state.integration-spec.ts
@@ -9,7 +9,13 @@ describe('Agent chat stream state', () => {
const workspaceId = v4();
- const publishChunk = (threadId: string, text: string) =>
+ const publishChunk = ({
+ threadId,
+ text,
+ }: {
+ threadId: string;
+ text: string;
+ }) =>
eventPublisherService.publish({
threadId,
workspaceId,
@@ -28,7 +34,7 @@ describe('Agent chat stream state', () => {
const streamId = v4();
await eventPublisherService.startStreamState({ threadId, streamId });
- await publishChunk(threadId, 'partial');
+ await publishChunk({ threadId, text: 'partial' });
await eventPublisherService.resetOwnedStreamState({ threadId, streamId });
@@ -47,7 +53,7 @@ describe('Agent chat stream state', () => {
threadId,
streamId: deadStreamId,
});
- await publishChunk(threadId, 'dead');
+ await publishChunk({ threadId, text: 'dead' });
await eventPublisherService.resetOwnedStreamState({
threadId,
streamId: deadStreamId,
@@ -57,7 +63,7 @@ describe('Agent chat stream state', () => {
threadId,
streamId: nextStreamId,
});
- await publishChunk(threadId, 'next');
+ await publishChunk({ threadId, text: 'next' });
await eventPublisherService.resetOwnedStreamState({
threadId,
diff --git a/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts b/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts
index ea7e3a9bc1f..dd59287612c 100644
--- a/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts
+++ b/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts
@@ -22,6 +22,8 @@ import { fromWorkspaceEntityToFlat } from 'src/engine/core-modules/workspace/uti
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { type AgentRunService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service';
import { type AgentExecutionResult } from 'src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type';
+import { type AgentChatStreamHeartbeatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-heartbeat.service';
+import { type AgentChatStreamRecoveryService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-recovery.service';
import { type AgentTriggerRunnerService } from 'src/engine/metadata-modules/ai/ai-agent-trigger/services/agent-trigger-runner.service';
import { AiExceptionCode } from 'src/engine/metadata-modules/ai/ai.exception';
import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
@@ -453,4 +455,67 @@ describe('agent runs that wait (integration)', () => {
});
expect(runTurn).toHaveBeenCalledTimes(3);
});
+
+ it('parks a run whose conversation is busy and starts it once the conversation is released', async () => {
+ const runTurn = mockAgent(replyingResult, replyingResult);
+ const agentRunService =
+ getAppProviderByClassName<AgentRunService>('AgentRunService');
+ const workspace = fromWorkspaceEntityToFlat(
+ await getCoreRepository<WorkspaceEntity>(WorkspaceEntity).findOneByOrFail(
+ { id: workspaceId },
+ ),
+ );
+ const callerApplication =
+ await getAppProviderByClassName<ApplicationLookupService>(
+ 'ApplicationLookupService',
+ ).findById({ id: agentApplicationId, workspaceId });
+ const thread = { key: `lead:${randomUUID()}` };
+ const runOnSameThread = (content: string) =>
+ agentRunService.run({
+ workspace,
+ requestUserWorkspaceId: null,
+ requestWorkspaceMemberId: null,
+ callerApplication: callerApplication ?? undefined,
+ input: {
+ agentUniversalIdentifier,
+ input: [{ role: 'user', content }],
+ thread,
+ waitForCompletion: false,
+ },
+ });
+
+ const { threadId } = await runOnSameThread('Follow up tomorrow');
+
+ await expectEventually(async () => {
+ expect(await findTurnStatuses(threadId)).toEqual(['completed']);
+ });
+
+ // a live stream, such as a member's chat reply, holds the conversation
+ const streamId = randomUUID();
+
+ await getAppProviderByClassName<AgentChatStreamHeartbeatService>(
+ 'AgentChatStreamHeartbeatService',
+ ).markClaimed(streamId);
+ await global.testDataSource.query(
+ `UPDATE "${schema}"."agentChatThread" SET "activeStreamId" = $2 WHERE id = $1`,
+ [threadId, streamId],
+ );
+
+ await runOnSameThread('Any news?');
+ await new Promise((resolve) => setTimeout(resolve, 1_000));
+
+ expect(await findTurnStatuses(threadId)).toEqual(['completed']);
+
+ await getAppProviderByClassName<AgentChatStreamRecoveryService>(
+ 'AgentChatStreamRecoveryService',
+ ).release({ threadId, workspaceId, streamId, shouldFlush: true });
+
+ await expectEventually(async () => {
+ expect(await findTurnStatuses(threadId)).toEqual([
+ 'completed',
+ 'completed',
+ ]);
+ });
+ expect(runTurn).toHaveBeenCalledTimes(2);
+ });
});
diff --git a/packages/twenty-server/test/integration/graphql/suites/chat-sender-execution.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/chat-sender-execution.integration-spec.ts
index a68e821ba74..36f36446d90 100644
--- a/packages/twenty-server/test/integration/graphql/suites/chat-sender-execution.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/chat-sender-execution.integration-spec.ts
@@ -8,6 +8,7 @@ import { getAppProviderByClassName } from 'test/integration/utils/get-app-provid
import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
import { type AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { type AgentChatQueueService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service';
import { type AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { type AgentChatActorService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-actor.service';
import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
@@ -25,10 +26,14 @@ const otherUserWorkspaceId = USER_WORKSPACE_DATA_SEED_IDS.JONY;
describe('Persisted chat senders', () => {
let chat: AgentChatService;
+ let queue: AgentChatQueueService;
let actors: AgentChatActorService;
const threadId = randomUUID();
beforeAll(async () => {
chat = getAppProviderByClassName<AgentChatService>('AgentChatService');
+ queue = getAppProviderByClassName<AgentChatQueueService>(
+ 'AgentChatQueueService',
+ );
actors = getAppProviderByClassName<AgentChatActorService>(
'AgentChatActorService',
);
@@ -53,7 +58,7 @@ describe('Persisted chat senders', () => {
parts: [{ type: 'text', text: 'Hello' }],
},
});
- const queued = await chat.queueMessage({
+ const queued = await queue.queueMessage({
workspaceId,
threadId,
userWorkspaceId,
@@ -97,18 +102,18 @@ describe('Persisted chat senders', () => {
userWorkspaceId: otherUserWorkspaceId,
}),
).rejects.toBeDefined();
- await chat.deleteQueuedMessage({ workspaceId, messageId: queued.id });
+ await queue.deleteQueuedMessage({ workspaceId, messageId: queued.id });
});
it('retains the queued sender through promotion and rejects a different executor', async () => {
- const queued = await chat.queueMessage({
+ const queued = await queue.queueMessage({
workspaceId,
threadId,
userWorkspaceId,
workspaceMemberId,
text: 'Next attributed message',
});
- const turnId = await chat.promoteQueuedMessage({
+ const turnId = await queue.promoteQueuedMessage({
workspaceId,
threadId,
messageId: queued.id,
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts
index 2be32cddab0..9d761053a64 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts
@@ -36,6 +36,7 @@ import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/m
import { type WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
import { type AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { type AgentChatQueueService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-queue.service';
import { type AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
import { type RecordSharePrincipalInput } from 'src/engine/core-modules/record-share/dtos/record-sharing.dto';
@@ -396,8 +397,9 @@ describe('Conversation sharing through the authenticated API', () => {
]!.id,
recordId: threadId,
};
- const chat =
- getAppProviderByClassName<AgentChatService>('AgentChatService');
+ const queue = getAppProviderByClassName<AgentChatQueueService>(
+ 'AgentChatQueueService',
+ );
const actors = getAppProviderByClassName<AgentChatActorService>(
'AgentChatActorService',
);
@@ -489,12 +491,12 @@ describe('Conversation sharing through the authenticated API', () => {
expect(
(await grant(RecordShareAccessLevel.READ_WRITE)).body.errors,
).toBeUndefined();
- const queued = await chat.queueMessage({
+ const queued = await queue.queueMessage({
...sender,
threadId,
text: 'Use my permissions',
});
- const turnId = await chat.promoteQueuedMessage({
+ const turnId = await queue.promoteQueuedMessage({
workspaceId,
threadId,
messageId: queued.id,
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts
index a9544a74937..5f43f652c36 100644
--- a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-execution.integration-spec.ts
@@ -50,7 +50,7 @@ import {
buildWaitingAgentExecutionResult,
mockAgentRunTurns,
} from 'test/utils/mock-agent-run-turns.util';
-import { type AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { type ToolCallAnswerRecorderService } from 'src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service';
import { type AgentChatThreadService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread.service';
import { type ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
@@ -1959,7 +1959,9 @@ describe('core workflow execution and queue compatibility (e2e)', () => {
const recordToolCallAnswer = jest
.spyOn(
- getAppProviderByClassName<AgentChatService>('AgentChatService'),
+ getAppProviderByClassName<ToolCallAnswerRecorderService>(
+ 'ToolCallAnswerRecorderService',
+ ),
'recordToolCallAnswer',
)
.mockRejectedValueOnce(new Error('Answer write failed'));
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-send-chat-message.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-send-chat-message.integration-spec.ts
index 94c992032a0..1103ba84997 100644
--- a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-send-chat-message.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-send-chat-message.integration-spec.ts
@@ -18,7 +18,7 @@ import { getAppProviderByClassName } from 'test/integration/utils/get-app-provid
import { WorkflowRunStatus } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';
import { type WorkflowRunWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service';
import { type AgentCallerConversationService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-caller-conversation.service';
-import { type AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
+import { type ToolCallAnswerRecorderService } from 'src/engine/metadata-modules/ai/ai-tool-call-answer/services/tool-call-answer-recorder.service';
import { type WorkflowRunInboxSenderWorkspaceService } from 'src/modules/workflow/workflow-executor/services/workflow-run-inbox-sender.workspace-service';
import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
@@ -389,10 +389,12 @@ describe('Send chat message workflow step', () => {
}, 120000);
it('never runs an approved action twice when recording the answer fails', async () => {
- const agentChatService =
- getAppProviderByClassName<AgentChatService>('AgentChatService');
+ const toolCallAnswerRecorderService =
+ getAppProviderByClassName<ToolCallAnswerRecorderService>(
+ 'ToolCallAnswerRecorderService',
+ );
const recordToolCallAnswer = jest
- .spyOn(agentChatService, 'recordToolCallAnswer')
+ .spyOn(toolCallAnswerRecorderService, 'recordToolCallAnswer')
.mockRejectedValueOnce(new Error('Database unavailable'));
let secondAnswerErrors: string | undefined;
let partResult: Record<string, unknown> | undefined;