Skip to content

The open alternative to Salesforce, designed for AI.

Record status, timing, model, usage and creator on agent turns (#27336)

Félix Malfait05425883c701
diff --git a/packages/twenty-docs/developers/extend/apps/logic/skills-and-agents.mdx b/packages/twenty-docs/developers/extend/apps/logic/skills-and-agents.mdx
index 19ca27b574d..ed2f04d8f85 100644
--- a/packages/twenty-docs/developers/extend/apps/logic/skills-and-agents.mdx
+++ b/packages/twenty-docs/developers/extend/apps/logic/skills-and-agents.mdx
@@ -202,8 +202,10 @@ const { result, threadId } = await runAgent({
- `additionalInstructions` are given to the model for this call only and are not
stored, which suits per-request guidance such as formatting rules or a
deadline. They work without a `thread` too.
-- A turn is stored once the run succeeds. A failed run leaves the conversation
- as it was.
+- Every run is stored as a turn with its status, failed ones included. Its
+ usage is stored when the agent returns, even if it ran out of credits. A
+ failed run is not part of the conversation, so the next call does not see
+ it.
- Calls on the same thread run one at a time: a second call waits for the
first to finish, so each one sees the turns before it.
- When turns run as different members (see below), each one only sees the text
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-upgrade-version-command.module.ts
index 38e1624062e..d35dbdf9069 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-upgrade-version-command.module.ts
@@ -13,6 +13,8 @@ import { BackfillAgentAndWorkflowIsSystemCommand } from 'src/database/commands/u
import { ScheduleAgentChatThreadSnoozeEndsCommand } from 'src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791093059050-schedule-agent-chat-thread-snooze-ends.command';
import { UnpinNewAiChatCommandMenuItemCommand } from 'src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1790942019634-unpin-new-ai-chat-command-menu-item.command';
import { TurnHiddenAgentMessagesIntoSystemMessagesCommand } from 'src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791204952095-turn-hidden-agent-messages-into-system-messages.command';
+import { AddAgentTurnRunFieldsCommand } from 'src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584393-add-agent-turn-run-fields.command';
+import { BackfillFailedAgentTurnsCommand } from 'src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584394-backfill-failed-agent-turns.command';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
@@ -37,6 +39,8 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
TurnHiddenAgentMessagesIntoSystemMessagesCommand,
DropWorkflowRunFromChatThreadsCommand,
DropAgentTurnEvaluationObjectCommand,
+ AddAgentTurnRunFieldsCommand,
+ BackfillFailedAgentTurnsCommand,
],
})
export class V2_46_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584393-add-agent-turn-run-fields.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584393-add-agent-turn-run-fields.command.ts
new file mode 100644
index 00000000000..c93023161c2
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584393-add-agent-turn-run-fields.command.ts
@@ -0,0 +1,208 @@
+import { Command } from 'nest-commander';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { AgentHistoryUpgradeStorageService } from 'src/database/commands/agent-history/agent-history-upgrade-storage.service';
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { getStandardFlatEntitiesToCreateOrThrow } from 'src/database/commands/upgrade-version-command/2-10/utils/get-standard-flat-entities-to-create-or-throw.util';
+import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { computeTwentyStandardApplicationAllFlatEntityMaps } from 'src/engine/workspace-manager/twenty-standard-application/utils/twenty-standard-application-all-flat-entity-maps.constant';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+
+const AGENT_TURN_FIELDS = STANDARD_OBJECTS.agentTurn.fields;
+
+const RUN_FIELD_UNIVERSAL_IDENTIFIERS = [
+ AGENT_TURN_FIELDS.status.universalIdentifier,
+ AGENT_TURN_FIELDS.error.universalIdentifier,
+ AGENT_TURN_FIELDS.startedAt.universalIdentifier,
+ AGENT_TURN_FIELDS.endedAt.universalIdentifier,
+ AGENT_TURN_FIELDS.modelId.universalIdentifier,
+ AGENT_TURN_FIELDS.inputTokens.universalIdentifier,
+ AGENT_TURN_FIELDS.outputTokens.universalIdentifier,
+ AGENT_TURN_FIELDS.cacheReadTokens.universalIdentifier,
+ AGENT_TURN_FIELDS.cacheCreationTokens.universalIdentifier,
+ AGENT_TURN_FIELDS.inputCredits.universalIdentifier,
+ AGENT_TURN_FIELDS.outputCredits.universalIdentifier,
+ AGENT_TURN_FIELDS.createdBy.universalIdentifier,
+];
+
+// Existing turns take the completed default, except the one holding a
+// conversation's open question, which still waits on its answer
+@RegisteredWorkspaceCommand('2.46.0', 1791227584393)
+@Command({
+ name: 'upgrade:2-46:add-agent-turn-run-fields',
+ description:
+ 'Add the status, timing, model, usage and creator of each agent turn',
+})
+export class AddAgentTurnRunFieldsCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly applicationService: ApplicationService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ private readonly storage: AgentHistoryUpgradeStorageService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.up(args);
+ }
+
+ async up({ workspaceId, options }: RunOnWorkspaceArgs): Promise<void> {
+ const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatObjectMetadataMaps',
+ 'flatFieldMetadataMaps',
+ ]);
+
+ if (
+ !isDefined(
+ flatObjectMetadataMaps.byUniversalIdentifier[
+ STANDARD_OBJECTS.agentTurn.universalIdentifier
+ ],
+ )
+ ) {
+ this.logger.log(
+ `agentTurn object not found for workspace ${workspaceId}, skipping`,
+ );
+
+ return;
+ }
+
+ const { twentyStandardFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+ const { allFlatEntityMaps: standardAllFlatEntityMaps } =
+ computeTwentyStandardApplicationAllFlatEntityMaps({
+ now: new Date().toISOString(),
+ workspaceId,
+ twentyStandardApplicationId: twentyStandardFlatApplication.id,
+ });
+
+ const fieldsToCreate =
+ getStandardFlatEntitiesToCreateOrThrow<FlatFieldMetadata>({
+ standardFlatEntityMaps: standardAllFlatEntityMaps.flatFieldMetadataMaps,
+ existingFlatEntityMaps: flatFieldMetadataMaps,
+ universalIdentifiers: RUN_FIELD_UNIVERSAL_IDENTIFIERS,
+ });
+
+ if (options.dryRun ?? false) {
+ this.logger.log(
+ `[DRY RUN] Would create ${fieldsToCreate.length} agentTurn field(s) and mark waiting turns for workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ // a rerun after a failed backfill finds the fields already there and must still mark the turns
+ if (fieldsToCreate.length > 0) {
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(
+ {
+ workspaceId,
+ isSystemBuild: true,
+ applicationUniversalIdentifier:
+ twentyStandardFlatApplication.universalIdentifier,
+ allFlatEntityOperationByMetadataName: {
+ fieldMetadata: {
+ flatEntityToCreate: fieldsToCreate,
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
+ },
+ },
+ );
+
+ if (result.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ result,
+ `Failed to create the agentTurn run fields for workspace ${workspaceId}`,
+ );
+ }
+ }
+
+ const waitingTurnCount = await this.storage.run(
+ workspaceId,
+ async ({ manager, table }) => {
+ const waitingTurns: { id: string }[] = await manager.query(
+ `UPDATE ${table('agentTurn')} turn SET "status" = 'waiting_for_input', "endedAt" = NULL
+ FROM ${table('agentChatThread')} thread
+ JOIN ${table('agentMessage')} message ON message.id = thread."pendingQuestionMessageId"
+ WHERE turn.id = message."turnId"
+ RETURNING turn.id`,
+ );
+
+ return waitingTurns.length;
+ },
+ );
+
+ this.logger.log(
+ `Workspace ${workspaceId}: created ${fieldsToCreate.length} agentTurn field(s) and marked ${waitingTurnCount} turn(s) as waiting`,
+ );
+ }
+
+ async down({ workspaceId, options }: RunOnWorkspaceArgs): Promise<void> {
+ const { flatFieldMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatFieldMetadataMaps',
+ ]);
+
+ const fieldsToDelete = RUN_FIELD_UNIVERSAL_IDENTIFIERS.map(
+ (universalIdentifier) =>
+ findFlatEntityByUniversalIdentifier<FlatFieldMetadata>({
+ flatEntityMaps: flatFieldMetadataMaps,
+ universalIdentifier,
+ }),
+ ).filter(isDefined);
+
+ if (fieldsToDelete.length === 0) {
+ return;
+ }
+
+ if (options.dryRun ?? false) {
+ this.logger.log(
+ `[DRY RUN] Would delete ${fieldsToDelete.length} agentTurn field(s) for workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ const { twentyStandardFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(
+ {
+ workspaceId,
+ isSystemBuild: true,
+ applicationUniversalIdentifier:
+ twentyStandardFlatApplication.universalIdentifier,
+ allFlatEntityOperationByMetadataName: {
+ fieldMetadata: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: fieldsToDelete,
+ flatEntityToUpdate: [],
+ },
+ },
+ },
+ );
+
+ if (result.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ result,
+ `Failed to delete the agentTurn run fields for workspace ${workspaceId}`,
+ );
+ }
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584394-backfill-failed-agent-turns.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584394-backfill-failed-agent-turns.command.ts
new file mode 100644
index 00000000000..2af36c61b5c
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-46/2-46-workspace-command-1791227584394-backfill-failed-agent-turns.command.ts
@@ -0,0 +1,104 @@
+import { Command } from 'nest-commander';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { AgentHistoryUpgradeStorageService } from 'src/database/commands/agent-history/agent-history-upgrade-storage.service';
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+// A failed stream is a failed turn: the error a thread held moves to its latest
+// turn, which retries and the chat banner now read. The thread column stays
+// until the 2.42 history move that still copies it is gone.
+@RegisteredWorkspaceCommand('2.46.0', 1791227584394)
+@Command({
+ name: 'upgrade:2-46:backfill-failed-agent-turns',
+ description:
+ 'Mark the latest turn of chat threads holding a stream error as failed, with that error',
+})
+export class BackfillFailedAgentTurnsCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly storage: AgentHistoryUpgradeStorageService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.up(args);
+ }
+
+ async up({ workspaceId, options }: RunOnWorkspaceArgs): Promise<void> {
+ const { flatFieldMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatFieldMetadataMaps',
+ ]);
+
+ const hasRequiredFields = [
+ STANDARD_OBJECTS.agentChatThread.fields.lastStreamError
+ .universalIdentifier,
+ STANDARD_OBJECTS.agentTurn.fields.status.universalIdentifier,
+ STANDARD_OBJECTS.agentTurn.fields.error.universalIdentifier,
+ ].every((universalIdentifier) =>
+ isDefined(
+ findFlatEntityByUniversalIdentifier<FlatFieldMetadata>({
+ flatEntityMaps: flatFieldMetadataMaps,
+ universalIdentifier,
+ }),
+ ),
+ );
+
+ if (!hasRequiredFields) {
+ this.logger.log(
+ `Chat history fields not found for workspace ${workspaceId}, skipping`,
+ );
+
+ return;
+ }
+
+ if (options.dryRun ?? false) {
+ this.logger.log(
+ `[DRY RUN] Would mark the latest turn of threads with a stream error as failed for workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ const failedTurnCount = await this.storage.run(
+ workspaceId,
+ async ({ manager, table }) => {
+ const failedTurns: { id: string }[] = await manager.query(
+ `UPDATE ${table('agentTurn')} turn SET
+ "status" = 'failed',
+ "error" = jsonb_build_object('code', thread."lastStreamError"->>'code', 'message', thread."lastStreamError"->>'message'),
+ "endedAt" = COALESCE((thread."lastStreamError"->>'failedAt')::timestamptz, now())
+ FROM ${table('agentChatThread')} thread
+ WHERE thread."lastStreamError" IS NOT NULL
+ AND turn."status" <> 'failed'
+ AND turn.id = (
+ SELECT latest.id FROM ${table('agentTurn')} latest
+ WHERE latest."threadId" = thread.id
+ ORDER BY latest."createdAt" DESC, latest.id DESC
+ LIMIT 1
+ )
+ RETURNING turn.id`,
+ );
+
+ return failedTurns.length;
+ },
+ );
+
+ this.logger.log(
+ `Workspace ${workspaceId}: marked ${failedTurnCount} turn(s) as failed`,
+ );
+ }
+
+ async down(_args: RunOnWorkspaceArgs): Promise<void> {
+ // The thread still holds the stream error it was backfilled from
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/actor/services/actor-from-auth-context.service.ts b/packages/twenty-server/src/engine/core-modules/actor/services/actor-from-auth-context.service.ts
index 8a94e341389..1300e77390c 100644
--- a/packages/twenty-server/src/engine/core-modules/actor/services/actor-from-auth-context.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/actor/services/actor-from-auth-context.service.ts
@@ -3,13 +3,7 @@ import { Injectable } from '@nestjs/common';
import { type ActorMetadata } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
-import { buildCreatedByFromApiKey } from 'src/engine/core-modules/actor/utils/build-created-by-from-api-key.util';
-import { buildCreatedByFromAgent } from 'src/engine/core-modules/actor/utils/build-created-by-from-agent.util';
-import { buildCreatedByFromApplication } from 'src/engine/core-modules/actor/utils/build-created-by-from-application.util';
-import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';
-import { isApiKeyAuthContext } from 'src/engine/core-modules/auth/guards/is-api-key-auth-context.guard';
-import { isApplicationAuthContext } from 'src/engine/core-modules/auth/guards/is-application-auth-context.guard';
-import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
+import { buildActorMetadataFromAuthContext } from 'src/engine/core-modules/actor/utils/build-actor-metadata-from-auth-context.util';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
@@ -118,7 +112,7 @@ export class ActorFromAuthContextService {
const clonedRecords = structuredClone(records);
- const actorMetadata = this.buildActorMetadata(authContext);
+ const actorMetadata = buildActorMetadataFromAuthContext(authContext);
for (const record of clonedRecords) {
this.injectActorToRecord(actorMetadata, record, fieldName);
@@ -145,36 +139,4 @@ export class ActorFromAuthContextService {
record[fieldName] = actorMetadata;
}
}
-
- private buildActorMetadata(authContext: WorkspaceAuthContext): ActorMetadata {
- if (isUserAuthContext(authContext)) {
- return buildCreatedByFromFullNameMetadata({
- fullNameMetadata: authContext.workspaceMember.name,
- workspaceMemberId: authContext.workspaceMemberId,
- });
- }
-
- if (isApiKeyAuthContext(authContext)) {
- return buildCreatedByFromApiKey({
- apiKey: authContext.apiKey,
- });
- }
-
- if (isApplicationAuthContext(authContext)) {
- if (isDefined(authContext.actingAgent)) {
- return buildCreatedByFromAgent({
- agent: authContext.actingAgent,
- applicationId: authContext.application.id,
- });
- }
-
- return buildCreatedByFromApplication({
- application: authContext.application,
- });
- }
-
- throw new Error(
- 'Unable to build actor metadata - no valid actor information found in auth context',
- );
- }
}
diff --git a/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-auth-context.util.ts b/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-auth-context.util.ts
new file mode 100644
index 00000000000..3e2247679f1
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-auth-context.util.ts
@@ -0,0 +1,45 @@
+import { type ActorMetadata } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { buildCreatedByFromAgent } from 'src/engine/core-modules/actor/utils/build-created-by-from-agent.util';
+import { buildCreatedByFromApiKey } from 'src/engine/core-modules/actor/utils/build-created-by-from-api-key.util';
+import { buildCreatedByFromApplication } from 'src/engine/core-modules/actor/utils/build-created-by-from-application.util';
+import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';
+import { isApiKeyAuthContext } from 'src/engine/core-modules/auth/guards/is-api-key-auth-context.guard';
+import { isApplicationAuthContext } from 'src/engine/core-modules/auth/guards/is-application-auth-context.guard';
+import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+
+export const buildActorMetadataFromAuthContext = (
+ authContext: WorkspaceAuthContext,
+): ActorMetadata => {
+ if (isUserAuthContext(authContext)) {
+ return buildCreatedByFromFullNameMetadata({
+ fullNameMetadata: authContext.workspaceMember.name,
+ workspaceMemberId: authContext.workspaceMemberId,
+ });
+ }
+
+ if (isApiKeyAuthContext(authContext)) {
+ return buildCreatedByFromApiKey({
+ apiKey: authContext.apiKey,
+ });
+ }
+
+ if (isApplicationAuthContext(authContext)) {
+ if (isDefined(authContext.actingAgent)) {
+ return buildCreatedByFromAgent({
+ agent: authContext.actingAgent,
+ applicationId: authContext.application.id,
+ });
+ }
+
+ return buildCreatedByFromApplication({
+ application: authContext.application,
+ });
+ }
+
+ throw new Error(
+ 'Unable to build actor metadata - no valid actor information found in auth context',
+ );
+};
diff --git a/packages/twenty-server/src/engine/core-modules/admin-panel/services/admin-panel-global-chat-threads.service.ts b/packages/twenty-server/src/engine/core-modules/admin-panel/services/admin-panel-global-chat-threads.service.ts
index e266e7a7f75..2bc324194d4 100644
--- a/packages/twenty-server/src/engine/core-modules/admin-panel/services/admin-panel-global-chat-threads.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/admin-panel/services/admin-panel-global-chat-threads.service.ts
@@ -15,6 +15,7 @@ import { AdminChatThreadScope } from 'src/engine/core-modules/admin-panel/enums/
import { AdminChatThreadSortDirection } from 'src/engine/core-modules/admin-panel/enums/admin-chat-thread-sort-direction.enum';
import { AdminChatThreadSortField } from 'src/engine/core-modules/admin-panel/enums/admin-chat-thread-sort-field.enum';
import { WORKSPACE_SETUP_CHAT_THREAD_ID_NAMESPACE } from 'src/engine/metadata-modules/ai/ai-chat/constants/workspace-setup-chat-thread-id-namespace.constant';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
type GlobalChatThreadsArgs = {
scope: AdminChatThreadScope;
@@ -113,7 +114,7 @@ export class AdminPanelGlobalChatThreadsService {
WITH candidates AS (
SELECT thread.id, thread.title, workspace.id AS "workspaceId", workspace."displayName" AS "workspaceDisplayName",
membership.id AS "userWorkspaceId", owner.email AS "userEmail", owner."firstName" AS "userFirstName", owner."lastName" AS "userLastName",
- thread."deletedAt", thread."createdAt", thread."updatedAt", thread."lastStreamError" IS NOT NULL AS "hasError",
+ thread."deletedAt", thread."createdAt", thread."updatedAt", COALESCE((SELECT turn.status = '${AgentTurnStatus.FAILED}' FROM ${table('agentTurn')} turn WHERE turn."threadId" = thread.id ORDER BY turn."createdAt" DESC, turn.id DESC LIMIT 1), false) AS "hasError",
(EXISTS (SELECT 1 FROM ${table('agentMessage')} context WHERE context."threadId" = thread.id AND (context.role = 'system' OR context."isHidden" = true))
OR (membership.id IS NOT NULL AND thread.id = public.uuid_generate_v5($2::uuid, workspace.id::text || ':' || membership.id::text))) AS "isOnboardingThread",
(SELECT COUNT(*)::int FROM ${table('agentMessage')} message WHERE message."threadId" = thread.id AND message."isHidden" = false AND message.role <> 'system') AS "messageCount",
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/__tests__/agent-run-conversation.service.close-turn.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/__tests__/agent-run-conversation.service.close-turn.spec.ts
new file mode 100644
index 00000000000..d3ca6f3445a
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/__tests__/agent-run-conversation.service.close-turn.spec.ts
@@ -0,0 +1,73 @@
+import { AgentRunConversationService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-conversation.service';
+import { type AgentExecutionResult } from 'src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type';
+
+const execution = {
+ modelId: 'model-id',
+ hasNoMoreAvailableCredits: false,
+} as AgentExecutionResult;
+
+const turn = {
+ workspaceId: 'workspace-id',
+ threadId: 'thread-id',
+ turnId: 'turn-id',
+};
+
+const buildService = () => {
+ const conversationWriterService = {
+ insertExecutionReply: jest
+ .fn()
+ .mockResolvedValue({ isAwaitingAnswer: false, replyParts: [] }),
+ };
+ const turnRecorderService = {
+ finishExecutedTurn: jest.fn().mockResolvedValue(undefined),
+ };
+
+ const service = new AgentRunConversationService(
+ {} as never,
+ conversationWriterService as never,
+ {} as never,
+ turnRecorderService as never,
+ );
+
+ return { service, conversationWriterService, turnRecorderService };
+};
+
+describe('AgentRunConversationService.closeTurn', () => {
+ it('leaves the turn waiting when the agent asked a question', async () => {
+ const { service, conversationWriterService, turnRecorderService } =
+ buildService();
+
+ conversationWriterService.insertExecutionReply.mockResolvedValue({
+ isAwaitingAnswer: true,
+ replyParts: [],
+ });
+
+ await service.closeTurn({ ...turn, agentId: 'agent-id', execution });
+
+ expect(turnRecorderService.finishExecutedTurn).toHaveBeenCalledWith({
+ ...turn,
+ execution,
+ isAwaitingAnswer: true,
+ });
+ });
+
+ it('fails the turn when its reply cannot be saved', async () => {
+ const { service, conversationWriterService, turnRecorderService } =
+ buildService();
+
+ conversationWriterService.insertExecutionReply.mockRejectedValue(
+ new Error('question slot taken'),
+ );
+
+ await expect(
+ service.closeTurn({ ...turn, agentId: 'agent-id', execution }),
+ ).rejects.toThrow('question slot taken');
+
+ expect(turnRecorderService.finishExecutedTurn).toHaveBeenCalledTimes(1);
+ expect(turnRecorderService.finishExecutedTurn).toHaveBeenCalledWith({
+ ...turn,
+ execution,
+ error: expect.objectContaining({ code: expect.any(String) }),
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/__tests__/agent-run.service.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/__tests__/agent-run.service.spec.ts
index 7cbe4b12b62..0b842716aca 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/__tests__/agent-run.service.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/__tests__/agent-run.service.spec.ts
@@ -25,7 +25,9 @@ const buildService = () => {
executeAgent: jest.fn().mockResolvedValue(executionResult),
};
const agentRunConversationService = {
- recordTurn: jest.fn().mockResolvedValue(undefined),
+ openTurn: jest.fn().mockResolvedValue('turn-id'),
+ closeTurn: jest.fn().mockResolvedValue(undefined),
+ failTurn: jest.fn().mockResolvedValue(undefined),
withThreadLock: jest.fn(({ work }) => work()),
};
const conversationReaderService = {
@@ -94,7 +96,7 @@ describe('AgentRunService', () => {
threadId: null,
});
expect(conversationReaderService.loadMessages).not.toHaveBeenCalled();
- expect(agentRunConversationService.recordTurn).not.toHaveBeenCalled();
+ expect(agentRunConversationService.openTurn).not.toHaveBeenCalled();
expect(agentAsyncExecutorService.executeAgent).toHaveBeenCalledWith(
expect.objectContaining({ priorMessages: [] }),
);
@@ -146,12 +148,18 @@ describe('AgentRunService', () => {
expect(agentAsyncExecutorService.executeAgent).toHaveBeenCalledWith(
expect.objectContaining({ priorMessages: PRIOR_MESSAGES }),
);
- expect(agentRunConversationService.recordTurn).toHaveBeenCalledWith(
+ expect(agentRunConversationService.openTurn).toHaveBeenCalledWith(
expect.objectContaining({
threadId,
title: AGENT.label,
actor,
messages: userInput('And the second one?'),
+ }),
+ );
+ expect(agentRunConversationService.closeTurn).toHaveBeenCalledWith(
+ expect.objectContaining({
+ threadId,
+ turnId: 'turn-id',
execution: executionResult,
}),
);
@@ -172,7 +180,7 @@ describe('AgentRunService', () => {
messages: userInput('Answer in Slack markdown\n\nAnd the second one?'),
}),
);
- expect(agentRunConversationService.recordTurn).toHaveBeenCalledWith(
+ expect(agentRunConversationService.openTurn).toHaveBeenCalledWith(
expect.objectContaining({
title: 'Acme renewal',
messages: userInput('And the second one?'),
@@ -185,7 +193,7 @@ describe('AgentRunService', () => {
const { service, agentRunConversationService } = buildService();
jest.spyOn(Logger.prototype, 'error').mockImplementation();
- agentRunConversationService.recordTurn.mockRejectedValue(
+ agentRunConversationService.openTurn.mockRejectedValue(
new Error('write failed'),
);
@@ -195,6 +203,27 @@ describe('AgentRunService', () => {
});
expect(result.success).toBe(true);
+ expect(agentRunConversationService.closeTurn).not.toHaveBeenCalled();
+ });
+
+ it('records the turn as failed when the execution throws', async () => {
+ const { service, agentAsyncExecutorService, agentRunConversationService } =
+ buildService();
+ const executionError = new Error('provider down');
+
+ jest.spyOn(Logger.prototype, 'error').mockImplementation();
+ agentAsyncExecutorService.executeAgent.mockRejectedValue(executionError);
+
+ const result = await run(service, {
+ input: userInput('And the second one?'),
+ thread: { key: 'thread' },
+ });
+
+ expect(result.success).toBe(false);
+ expect(agentRunConversationService.failTurn).toHaveBeenCalledWith(
+ expect.objectContaining({ turnId: 'turn-id', error: executionError }),
+ );
+ expect(agentRunConversationService.closeTurn).not.toHaveBeenCalled();
});
it('refuses a thread without an application token', async () => {
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-async-executor.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-async-executor.service.ts
index b3930fa24b6..7152242d480 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-async-executor.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-async-executor.service.ts
@@ -689,6 +689,10 @@ export class AgentAsyncExecutorService {
modelId: registeredModel.modelId,
totalCostInDollars,
creditsUsedMicro,
+ turnUsage: this.aiBillingService.calculateStepsTurnUsage(
+ registeredModel.modelId,
+ executionSteps,
+ ),
};
} catch (error) {
if (error instanceof AiException) {
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-conversation.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-conversation.service.ts
index 578f4f78df2..a1776b72627 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-conversation.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-conversation.service.ts
@@ -6,9 +6,16 @@ import {
type ExtendedUIMessagePart,
} from 'twenty-shared/ai';
import { type RunAgentMessage } from 'twenty-shared/application';
+import { type ActorMetadata } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
+import { buildCreatedByFromApplication } from 'src/engine/core-modules/actor/utils/build-created-by-from-application.util';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { CacheLockService } from 'src/engine/core-modules/cache-lock/cache-lock.service';
+import { type AgentExecutionResult } from 'src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type';
+import { mapErrorToStreamError } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
import {
AGENT_RUN_THREAD_LOCK_RETRY_INTERVAL_MS,
AGENT_RUN_THREAD_LOCK_TTL_MS,
@@ -19,7 +26,6 @@ import { InjectAgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-
import { AgentConversationWriterService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service';
import { type AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
import { type AgentConversationActor } from 'src/engine/metadata-modules/ai/ai-history/types/agent-conversation-actor.type';
-import { type RecordableAgentExecution } from 'src/engine/metadata-modules/ai/ai-history/types/recordable-agent-execution.type';
@Injectable()
export class AgentRunConversationService {
@@ -28,6 +34,7 @@ export class AgentRunConversationService {
private readonly threadRepository: AgentHistoryRepository<AgentChatThreadWorkspaceEntity>,
private readonly conversationWriterService: AgentConversationWriterService,
private readonly cacheLockService: CacheLockService,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
withThreadLock<TResult>({
@@ -52,33 +59,32 @@ export class AgentRunConversationService {
);
}
- async recordTurn({
+ // The turn is written before the agent runs, so a run in progress or one that fails is on record
+ async openTurn({
workspaceId,
threadId,
title,
agentId,
- applicationId,
+ application,
+ createdBy,
actor,
messages,
- startedAt,
- execution,
}: {
workspaceId: string;
threadId: string;
title: string;
agentId: string;
- applicationId: string;
+ application: FlatApplication;
+ createdBy?: ActorMetadata;
actor: AgentConversationActor;
messages: RunAgentMessage[];
- startedAt: Date;
- execution: RecordableAgentExecution;
- }): Promise<void> {
+ }): Promise<string> {
const existingThread = await this.threadRepository.findOne(workspaceId, {
where: { id: threadId },
select: ['id'],
});
- await this.conversationWriterService.runInTransaction(
+ return this.conversationWriterService.runInTransaction(
workspaceId,
async (scope) => {
if (!isDefined(existingThread)) {
@@ -89,6 +95,9 @@ export class AgentRunConversationService {
workspaceId,
threadId,
agentId,
+ status: AgentTurnStatus.RUNNING,
+ createdBy:
+ createdBy ?? buildCreatedByFromApplication({ application }),
scope,
});
@@ -101,25 +110,72 @@ export class AgentRunConversationService {
agentId: null,
senderUserWorkspaceId:
actor.type === 'user' ? actor.userWorkspaceId : null,
- senderApplicationId: applicationId,
- processedAt: startedAt,
+ senderApplicationId: application.id,
parts: this.buildUserMessageParts(message),
scope,
});
}
- await this.conversationWriterService.insertExecutionReply({
- workspaceId,
- threadId,
- turnId,
- agentId,
- execution,
- scope,
- });
+ return turnId;
},
);
}
+ async closeTurn({
+ workspaceId,
+ threadId,
+ turnId,
+ agentId,
+ execution,
+ }: {
+ workspaceId: string;
+ threadId: string;
+ turnId: string;
+ agentId: string;
+ execution: AgentExecutionResult;
+ }): Promise<void> {
+ const turn = { workspaceId, threadId, turnId, execution };
+
+ const { isAwaitingAnswer } = await this.conversationWriterService
+ .insertExecutionReply({
+ workspaceId,
+ threadId,
+ turnId,
+ agentId,
+ execution,
+ })
+ .catch(async (error: unknown) => {
+ await this.turnRecorderService.finishExecutedTurn({
+ ...turn,
+ error: mapErrorToStreamError(error),
+ });
+
+ throw error;
+ });
+
+ await this.turnRecorderService.finishExecutedTurn({
+ ...turn,
+ isAwaitingAnswer,
+ });
+ }
+
+ async failTurn({
+ workspaceId,
+ turnId,
+ error,
+ }: {
+ workspaceId: string;
+ turnId: string;
+ error: unknown;
+ }): Promise<void> {
+ await this.turnRecorderService.finish({
+ workspaceId,
+ turnId,
+ status: AgentTurnStatus.FAILED,
+ error: mapErrorToStreamError(error),
+ });
+ }
+
private buildUserMessageParts(
message: RunAgentMessage,
): ExtendedUIMessagePart[] {
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.ts
index 860aff6b366..ad37928c777 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run.service.ts
@@ -15,6 +15,7 @@ import { type FlatWorkspace } from 'src/engine/core-modules/workspace/types/flat
import { AgentActorContextService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-actor-context.service';
import { AgentAsyncExecutorService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-async-executor.service';
import { AgentRunConversationService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-conversation.service';
+import { type AgentExecutionResult } from 'src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type';
import { type RunAsWorkspaceMemberContext } from 'src/engine/metadata-modules/ai/ai-agent-execution/types/run-as-workspace-member-context.type';
import { addAdditionalInstructionsToLastRunAgentMessage } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/add-additional-instructions-to-last-run-agent-message.util';
import { buildAgentRunThreadId } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/build-agent-run-thread-id.util';
@@ -170,23 +171,74 @@ export class AgentRunService {
})
: [];
- const startedAt = new Date();
-
- const executionResult = await withDedicatedAiTrace(() =>
- this.agentAsyncExecutorService.executeAgent({
- agent,
- messages: executionMessages,
- priorMessages,
- baseSystemPrompt: AGENT_RUN_BASE_SYSTEM_PROMPT,
- actorContext: runAsContext?.actorContext,
- authContext,
- workspaceId: workspace.id,
- userWorkspaceId:
- runAsContext?.authContext.userWorkspaceId ?? requestUserWorkspaceId,
- runAsRoleId: runAsContext?.roleId,
- toolLoadingStrategy: 'lazy',
- }),
- );
+ const turnId = isDefined(threadId)
+ ? await this.recordConversation({
+ threadId,
+ agentUniversalIdentifier: input.agentUniversalIdentifier,
+ record: () =>
+ this.agentRunConversationService.openTurn({
+ workspaceId: workspace.id,
+ threadId,
+ title: threadTitle,
+ agentId: agent.id,
+ application,
+ actor,
+ createdBy: runAsContext?.actorContext,
+ messages,
+ }),
+ })
+ : null;
+
+ let executionResult: AgentExecutionResult;
+
+ try {
+ executionResult = await withDedicatedAiTrace(() =>
+ this.agentAsyncExecutorService.executeAgent({
+ agent,
+ messages: executionMessages,
+ priorMessages,
+ baseSystemPrompt: AGENT_RUN_BASE_SYSTEM_PROMPT,
+ actorContext: runAsContext?.actorContext,
+ authContext,
+ workspaceId: workspace.id,
+ userWorkspaceId:
+ runAsContext?.authContext.userWorkspaceId ??
+ requestUserWorkspaceId,
+ runAsRoleId: runAsContext?.roleId,
+ toolLoadingStrategy: 'lazy',
+ }),
+ );
+ } catch (error) {
+ if (isDefined(threadId) && isDefined(turnId)) {
+ await this.recordConversation({
+ threadId,
+ agentUniversalIdentifier: input.agentUniversalIdentifier,
+ record: () =>
+ this.agentRunConversationService.failTurn({
+ workspaceId: workspace.id,
+ turnId,
+ error,
+ }),
+ });
+ }
+
+ throw error;
+ }
+
+ if (isDefined(threadId) && isDefined(turnId)) {
+ await this.recordConversation({
+ threadId,
+ agentUniversalIdentifier: input.agentUniversalIdentifier,
+ record: () =>
+ this.agentRunConversationService.closeTurn({
+ workspaceId: workspace.id,
+ threadId,
+ turnId,
+ agentId: agent.id,
+ execution: executionResult,
+ }),
+ });
+ }
if (executionResult.hasNoMoreAvailableCredits) {
return {
@@ -197,27 +249,6 @@ export class AgentRunService {
};
}
- if (isDefined(threadId)) {
- await this.agentRunConversationService
- .recordTurn({
- workspaceId: workspace.id,
- threadId,
- title: threadTitle,
- agentId: agent.id,
- applicationId: application.id,
- actor,
- messages,
- startedAt,
- execution: executionResult,
- })
- .catch((error: unknown) =>
- this.logger.error(
- `Failed to record the turn of ${input.agentUniversalIdentifier} in thread ${threadId}`,
- error instanceof Error ? error.stack : error,
- ),
- );
- }
-
return {
result: executionResult.result,
error: null,
@@ -256,6 +287,28 @@ export class AgentRunService {
}
}
+ // A record of the run, not its outcome, so a write failure must not fail the run
+ private async recordConversation<TResult>({
+ threadId,
+ agentUniversalIdentifier,
+ record,
+ }: {
+ threadId: string;
+ agentUniversalIdentifier: string;
+ record: () => Promise<TResult>;
+ }): Promise<TResult | null> {
+ try {
+ return await record();
+ } catch (error) {
+ this.logger.error(
+ `Failed to record the turn of ${agentUniversalIdentifier} in thread ${threadId}`,
+ error instanceof Error ? error.stack : error,
+ );
+
+ return null;
+ }
+ }
+
private assertCanContinueConversation({
callerApplication,
messages,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type.ts
index d813dc8dfc9..faf0c80cf9a 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type.ts
@@ -1,5 +1,7 @@
import { type LanguageModelUsage, type StepResult, type ToolSet } from 'ai';
+import { type AgentTurnUsage } from 'src/engine/metadata-modules/ai/ai-history/types/agent-turn-usage.type';
+
export type AgentExecutionResult = {
result: object;
usage: LanguageModelUsage;
@@ -11,4 +13,5 @@ export type AgentExecutionResult = {
modelId: string;
totalCostInDollars: number;
creditsUsedMicro: number;
+ turnUsage: AgentTurnUsage;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/__tests__/agent-trigger-runner.service.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/__tests__/agent-trigger-runner.service.spec.ts
index 341db1b3fb6..445eec58486 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/__tests__/agent-trigger-runner.service.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/__tests__/agent-trigger-runner.service.spec.ts
@@ -47,7 +47,9 @@ const buildAgent = (isTriggerActive = true) => ({
describe('AgentTriggerRunnerService', () => {
let service: AgentTriggerRunnerService;
let executeAgent: jest.Mock;
- let recordTurn: jest.Mock;
+ let openTurn: jest.Mock;
+ let closeTurn: jest.Mock;
+ let failTurn: jest.Mock;
let currentRoleId: string | undefined;
let findAgent: jest.Mock;
let findApplication: jest.Mock;
@@ -59,7 +61,9 @@ describe('AgentTriggerRunnerService', () => {
.fn()
.mockResolvedValue({ id: 'application-id', name: 'App' });
executeAgent = jest.fn().mockResolvedValue({ result: { text: 'done' } });
- recordTurn = jest.fn().mockResolvedValue(undefined);
+ openTurn = jest.fn().mockResolvedValue('turn-id');
+ closeTurn = jest.fn().mockResolvedValue(undefined);
+ failTurn = jest.fn().mockResolvedValue(undefined);
const module: TestingModule = await Test.createTestingModule({
providers: [
@@ -70,7 +74,7 @@ describe('AgentTriggerRunnerService', () => {
},
{
provide: AgentRunConversationService,
- useValue: { recordTurn },
+ useValue: { openTurn, closeTurn, failTurn },
},
{
provide: ApplicationLookupService,
@@ -119,7 +123,30 @@ describe('AgentTriggerRunnerService', () => {
toolLoadingStrategy: 'lazy',
}),
);
- expect(recordTurn).toHaveBeenCalled();
+ expect(openTurn).toHaveBeenCalledWith(
+ expect.objectContaining({
+ agentId: AGENT_ID,
+ createdBy: expect.objectContaining({ name: 'Enricher' }),
+ }),
+ );
+ expect(closeTurn).toHaveBeenCalledWith(
+ expect.objectContaining({ turnId: 'turn-id' }),
+ );
+ });
+
+ it('should record a failed run when the agent throws', async () => {
+ const error = new Error('model unavailable');
+
+ executeAgent.mockRejectedValue(error);
+
+ await expect(service.run(JOB_DATA)).rejects.toThrow('model unavailable');
+
+ expect(failTurn).toHaveBeenCalledWith({
+ workspaceId: WORKSPACE_ID,
+ turnId: 'turn-id',
+ error,
+ });
+ expect(closeTurn).not.toHaveBeenCalled();
});
it.each([
@@ -142,7 +169,7 @@ describe('AgentTriggerRunnerService', () => {
await service.run(JOB_DATA);
expect(executeAgent).not.toHaveBeenCalled();
- expect(recordTurn).not.toHaveBeenCalled();
+ expect(openTurn).not.toHaveBeenCalled();
});
it('should not run when the agent role changed since dispatch', async () => {
@@ -153,8 +180,17 @@ describe('AgentTriggerRunnerService', () => {
expect(executeAgent).not.toHaveBeenCalled();
});
- it('should not fail the run when recording it fails', async () => {
- recordTurn.mockRejectedValue(new Error('history unavailable'));
+ it('should still run the agent when the run cannot be recorded', async () => {
+ openTurn.mockRejectedValue(new Error('history unavailable'));
+
+ await expect(service.run(JOB_DATA)).resolves.toBeUndefined();
+
+ expect(executeAgent).toHaveBeenCalled();
+ expect(closeTurn).not.toHaveBeenCalled();
+ });
+
+ it('should not fail the run when closing its record fails', async () => {
+ closeTurn.mockRejectedValue(new Error('history unavailable'));
await expect(service.run(JOB_DATA)).resolves.toBeUndefined();
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/agent-trigger-runner.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/agent-trigger-runner.service.ts
index 4b552d5756b..c178437ba63 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/agent-trigger-runner.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/services/agent-trigger-runner.service.ts
@@ -12,6 +12,7 @@ import { fromWorkspaceEntityToFlat } from 'src/engine/core-modules/workspace/uti
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AgentAsyncExecutorService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-async-executor.service';
import { AgentRunConversationService } from 'src/engine/metadata-modules/ai/ai-agent-execution/services/agent-run-conversation.service';
+import { type AgentExecutionResult } from 'src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type';
import { buildAgentRunThreadId } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/build-agent-run-thread-id.util';
import { AGENT_TRIGGER_BASE_SYSTEM_PROMPT } from 'src/engine/metadata-modules/ai/ai-agent-trigger/constants/agent-trigger-base-system-prompt.const';
import { type RunAgentTriggerJobData } from 'src/engine/metadata-modules/ai/ai-agent-trigger/types/run-agent-trigger-job-data.type';
@@ -105,42 +106,68 @@ export class AgentTriggerRunnerService {
agentId: agent.id,
threadKey: `trigger:${trigger.id}:${v4()}`,
});
- const startedAt = new Date();
+ const createdBy = buildCreatedByFromAgent({
+ agent: actingAgent,
+ applicationId: application.id,
+ });
+ const logRecordFailure = (error: unknown) => {
+ this.logger.error(
+ `Failed to record the run of trigger ${triggerId} of agent ${agentId} in thread ${threadId}`,
+ error instanceof Error ? error.stack : error,
+ );
- const execution = await withDedicatedAiTrace(() =>
- this.agentAsyncExecutorService.executeAgent({
- agent,
- messages,
- baseSystemPrompt: AGENT_TRIGGER_BASE_SYSTEM_PROMPT,
- actorContext: buildCreatedByFromAgent({
- agent: actingAgent,
- applicationId: application.id,
- }),
- authContext,
- workspaceId,
- userWorkspaceId: null,
- toolLoadingStrategy: 'lazy',
- }),
- );
+ return null;
+ };
- // The agent already acted through its tools, so a failed log write must not fail the run
- await this.agentRunConversationService
- .recordTurn({
+ // The agent acts through its tools, so a failed log write must not fail the run
+ const turnId = await this.agentRunConversationService
+ .openTurn({
workspaceId,
threadId,
title: agent.label,
agentId: agent.id,
- applicationId: application.id,
+ application,
+ createdBy,
actor: { type: 'application', applicationId: application.id },
messages,
- startedAt,
- execution,
})
- .catch((error: unknown) =>
- this.logger.error(
- `Failed to record the run of trigger ${triggerId} of agent ${agentId} in thread ${threadId}`,
- error instanceof Error ? error.stack : error,
- ),
+ .catch(logRecordFailure);
+
+ let execution: AgentExecutionResult;
+
+ try {
+ execution = await withDedicatedAiTrace(() =>
+ this.agentAsyncExecutorService.executeAgent({
+ agent,
+ messages,
+ baseSystemPrompt: AGENT_TRIGGER_BASE_SYSTEM_PROMPT,
+ actorContext: createdBy,
+ authContext,
+ workspaceId,
+ userWorkspaceId: null,
+ toolLoadingStrategy: 'lazy',
+ }),
);
+ } catch (error) {
+ if (isDefined(turnId)) {
+ await this.agentRunConversationService
+ .failTurn({ workspaceId, turnId, error })
+ .catch(logRecordFailure);
+ }
+
+ throw error;
+ }
+
+ if (isDefined(turnId)) {
+ await this.agentRunConversationService
+ .closeTurn({
+ workspaceId,
+ threadId,
+ turnId,
+ agentId: agent.id,
+ execution,
+ })
+ .catch(logRecordFailure);
+ }
}
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/services/ai-billing.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/services/ai-billing.service.ts
index bd0b982a1a5..301c733e0da 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/services/ai-billing.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/services/ai-billing.service.ts
@@ -10,12 +10,14 @@ import { type RecordUsageInput } from 'src/engine/core-modules/usage/types/recor
import { type UsageSpenders } from 'src/engine/core-modules/usage/types/usage-spenders.type';
import { NATIVE_WEB_SEARCH_COST_PER_CALL_DOLLARS } from 'src/engine/metadata-modules/ai/ai-billing/constants/native-web-search-cost-per-call-dollars';
import { type BillingTokenUsage } from 'src/engine/metadata-modules/ai/ai-billing/types/billing-token-usage.type';
+import { computeAgentTurnUsageFromSteps } from 'src/engine/metadata-modules/ai/ai-billing/utils/compute-agent-turn-usage-from-steps.util';
import { computeStepCostBreakdown } from 'src/engine/metadata-modules/ai/ai-billing/utils/compute-step-cost-breakdown.util';
import { convertDollarsToCreditsMicro } from 'src/engine/metadata-modules/ai/ai-billing/utils/convert-dollars-to-credits-micro.util';
import { extractCacheCreationTokens } from 'src/engine/metadata-modules/ai/ai-billing/utils/extract-cache-creation-tokens.util';
import { AiModelRegistryService } from 'src/engine/metadata-modules/ai/ai-models/services/ai-model-registry.service';
import { type AiModelCostConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-model-cost-config.type';
import { type ModelId } from 'src/engine/metadata-modules/ai/ai-models/types/model-id.type';
+import { type AgentTurnUsage } from 'src/engine/metadata-modules/ai/ai-history/types/agent-turn-usage.type';
export type BillingUsageInput = {
usage: BillingTokenUsage;
@@ -80,6 +82,16 @@ export class AiBillingService {
);
}
+ calculateStepsTurnUsage(
+ modelId: ModelId,
+ steps: {
+ usage: BillingTokenUsage;
+ providerMetadata?: Record<string, Record<string, unknown> | undefined>;
+ }[],
+ ): AgentTurnUsage {
+ return computeAgentTurnUsageFromSteps(this.getCostConfig(modelId), steps);
+ }
+
calculateCost(modelId: ModelId, billingInput: BillingUsageInput): number {
const model = this.getCostConfig(modelId);
const breakdown = computeStepCostBreakdown(model, billingInput);
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/utils/__tests__/compute-agent-turn-usage-from-steps.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/utils/__tests__/compute-agent-turn-usage-from-steps.util.spec.ts
new file mode 100644
index 00000000000..a7bf48ea6ff
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/utils/__tests__/compute-agent-turn-usage-from-steps.util.spec.ts
@@ -0,0 +1,62 @@
+import { computeAgentTurnUsageFromSteps } from 'src/engine/metadata-modules/ai/ai-billing/utils/compute-agent-turn-usage-from-steps.util';
+import { type AiModelCostConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-model-cost-config.type';
+
+const MODEL_COST_CONFIG: AiModelCostConfig = {
+ modelId: 'test-model',
+ inputCostPerMillionTokens: 1,
+ outputCostPerMillionTokens: 2,
+ cachedInputCostPerMillionTokens: 0.5,
+ longContextCost: {
+ inputCostPerMillionTokens: 10,
+ outputCostPerMillionTokens: 20,
+ thresholdTokens: 200_000,
+ },
+};
+
+describe('computeAgentTurnUsageFromSteps', () => {
+ it('is empty for an execution without steps', () => {
+ expect(computeAgentTurnUsageFromSteps(MODEL_COST_CONFIG, [])).toEqual({
+ inputTokens: 0,
+ outputTokens: 0,
+ cacheReadTokens: 0,
+ cacheCreationTokens: 0,
+ inputCredits: 0,
+ outputCredits: 0,
+ });
+ });
+
+ it('prices each step on its own, so two steps under the long-context threshold keep the base rate', () => {
+ const step = { usage: { inputTokens: 150_000, outputTokens: 1_000 } };
+
+ expect(
+ computeAgentTurnUsageFromSteps(MODEL_COST_CONFIG, [step, step]),
+ ).toEqual({
+ inputTokens: 300_000,
+ outputTokens: 2_000,
+ cacheReadTokens: 0,
+ cacheCreationTokens: 0,
+ inputCredits: 300_000,
+ outputCredits: 4_000,
+ });
+ });
+
+ it('counts cache reads and cache writes', () => {
+ const turnUsage = computeAgentTurnUsageFromSteps(MODEL_COST_CONFIG, [
+ {
+ usage: {
+ inputTokens: 1_000,
+ outputTokens: 10,
+ inputTokenDetails: { cacheReadTokens: 400 },
+ },
+ providerMetadata: {
+ anthropic: { cacheCreationInputTokens: 200 },
+ },
+ },
+ ]);
+
+ expect(turnUsage).toMatchObject({
+ cacheReadTokens: 400,
+ cacheCreationTokens: 200,
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/utils/compute-agent-turn-usage-from-steps.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/utils/compute-agent-turn-usage-from-steps.util.ts
new file mode 100644
index 00000000000..ea550fcc66e
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-billing/utils/compute-agent-turn-usage-from-steps.util.ts
@@ -0,0 +1,57 @@
+import { type BillingTokenUsage } from 'src/engine/metadata-modules/ai/ai-billing/types/billing-token-usage.type';
+import { computeStepCostBreakdown } from 'src/engine/metadata-modules/ai/ai-billing/utils/compute-step-cost-breakdown.util';
+import { convertDollarsToCreditsMicro } from 'src/engine/metadata-modules/ai/ai-billing/utils/convert-dollars-to-credits-micro.util';
+import { extractCacheCreationTokens } from 'src/engine/metadata-modules/ai/ai-billing/utils/extract-cache-creation-tokens.util';
+import { type AgentTurnUsage } from 'src/engine/metadata-modules/ai/ai-history/types/agent-turn-usage.type';
+import { type AiModelCostConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-model-cost-config.type';
+
+type AgentTurnUsageStep = {
+ usage?: BillingTokenUsage;
+ providerMetadata?: Record<string, Record<string, unknown> | undefined>;
+};
+
+const EMPTY_AGENT_TURN_USAGE: AgentTurnUsage = {
+ inputTokens: 0,
+ outputTokens: 0,
+ cacheReadTokens: 0,
+ cacheCreationTokens: 0,
+ inputCredits: 0,
+ outputCredits: 0,
+};
+
+// each step is priced on its own, so a chat stream adding steps as they end
+// and an execution adding them at the end reach the same totals
+export const addStepToAgentTurnUsage = (
+ model: AiModelCostConfig,
+ turnUsage: AgentTurnUsage,
+ step: AgentTurnUsageStep,
+): AgentTurnUsage => {
+ const cacheCreationTokens = extractCacheCreationTokens(step.providerMetadata);
+ const breakdown = computeStepCostBreakdown(model, {
+ usage: step.usage,
+ cacheCreationTokens,
+ });
+
+ return {
+ inputTokens: turnUsage.inputTokens + breakdown.tokenCounts.totalInputTokens,
+ outputTokens: turnUsage.outputTokens + (step.usage?.outputTokens ?? 0),
+ cacheReadTokens:
+ turnUsage.cacheReadTokens + breakdown.tokenCounts.cachedInputTokens,
+ cacheCreationTokens: turnUsage.cacheCreationTokens + cacheCreationTokens,
+ inputCredits:
+ turnUsage.inputCredits +
+ convertDollarsToCreditsMicro(breakdown.inputCostInDollars),
+ outputCredits:
+ turnUsage.outputCredits +
+ convertDollarsToCreditsMicro(breakdown.outputCostInDollars),
+ };
+};
+
+export const computeAgentTurnUsageFromSteps = (
+ model: AiModelCostConfig,
+ steps: AgentTurnUsageStep[],
+): AgentTurnUsage =>
+ steps.reduce<AgentTurnUsage>(
+ (turnUsage, step) => addStepToAgentTurnUsage(model, turnUsage, step),
+ EMPTY_AGENT_TURN_USAGE,
+ );
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/__tests__/stream-agent-chat.job.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/__tests__/stream-agent-chat.job.spec.ts
index b578481c678..ef04e6938ef 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/__tests__/stream-agent-chat.job.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/jobs/__tests__/stream-agent-chat.job.spec.ts
@@ -8,6 +8,7 @@ import { AgentChatStreamRecoveryService } from 'src/engine/metadata-modules/ai/a
import { type StreamAgentChatJobData } from 'src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat-job.types';
import { type AiModelConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-model-config.type';
import { AiExceptionCode } from 'src/engine/metadata-modules/ai/ai.exception';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
type PublishedEvent = { type: string } & Record<string, unknown>;
@@ -217,10 +218,11 @@ describe('StreamAgentChatJob', () => {
} = {}) => {
const publishedEvents: PublishedEvent[] = [];
- const threadUsageQuery = jest.fn(async () =>
- Array.from({ length: totalsUpdateAffected }, () => ({
- id: 'thread-id',
- })),
+ const threadUsageQuery = jest.fn(
+ async (_sql?: string, _parameters?: unknown[]) =>
+ Array.from({ length: totalsUpdateAffected }, () => ({
+ id: 'thread-id',
+ })),
);
const threadRepository = {
findOne: jest.fn().mockResolvedValue({
@@ -309,7 +311,13 @@ describe('StreamAgentChatJob', () => {
userWorkspaceId: 'user-workspace-id',
applicationId: null,
};
- const authorization = { authContext: { workspaceMemberId: 'member' } };
+ const authorization = {
+ authContext: {
+ type: 'user',
+ workspaceMemberId: 'member',
+ workspaceMember: { name: { firstName: 'Tim', lastName: 'Apple' } },
+ },
+ };
const actorService = {
authorizeJob: jest.fn().mockResolvedValue({
sender,
@@ -317,6 +325,21 @@ describe('StreamAgentChatJob', () => {
message: { id: 'user-message-id', turnId: 'turn-id' },
}),
};
+ const turnRecorderService = {
+ markRunning: jest.fn().mockResolvedValue(true),
+ recordUsage: jest.fn().mockResolvedValue(undefined),
+ finish: jest.fn().mockResolvedValue(true),
+ };
+ const claimReleases = () =>
+ threadUsageQuery.mock.calls
+ .filter(([sql]) => String(sql).includes('"activeStreamId" = NULL'))
+ .map(([, parameters]) => {
+ const turnError = (parameters as unknown[])[3] as string | null;
+
+ return {
+ turnError: turnError === null ? null : JSON.parse(turnError),
+ };
+ });
const job = new StreamAgentChatJob(
threadRepository as never,
workspaceRepository as never,
@@ -337,6 +360,7 @@ describe('StreamAgentChatJob', () => {
aiModelRegistryService as never,
actorService as never,
sharingService as never,
+ turnRecorderService as never,
);
const turnCounts = (key: string) =>
@@ -347,6 +371,8 @@ describe('StreamAgentChatJob', () => {
return {
job,
actorService,
+ turnRecorderService,
+ claimReleases,
chatExecutionService,
publishedEvents,
threadRepository,
@@ -380,7 +406,7 @@ describe('StreamAgentChatJob', () => {
userWorkspaceId: 'user-workspace-id',
}),
authorization: expect.objectContaining({
- authContext: { workspaceMemberId: 'member' },
+ authContext: expect.objectContaining({ workspaceMemberId: 'member' }),
}),
}),
);
@@ -389,6 +415,52 @@ describe('StreamAgentChatJob', () => {
);
});
+ it('runs the turn as its sender before streaming', async () => {
+ const { job, turnRecorderService, chatExecutionService } = buildJob();
+
+ await job.handle(jobData);
+
+ expect(turnRecorderService.markRunning).toHaveBeenCalledWith({
+ workspaceId: 'workspace-id',
+ turnId: 'turn-id',
+ modelId: 'openai/gpt-5.6-luna',
+ createdBy: expect.objectContaining({
+ source: 'MANUAL',
+ workspaceMemberId: 'member',
+ name: 'Tim Apple',
+ }),
+ streamClaim: { threadId: 'thread-id', streamId: 'stream-id' },
+ });
+ expect(
+ turnRecorderService.markRunning.mock.invocationCallOrder[0],
+ ).toBeLessThan(chatExecutionService.streamChat.mock.invocationCallOrder[0]);
+ });
+
+ it('does not stream a turn whose stream was stopped while starting', async () => {
+ const { job, turnRecorderService, chatExecutionService } = buildJob();
+
+ turnRecorderService.markRunning.mockResolvedValue(false);
+
+ await job.handle(jobData);
+
+ expect(chatExecutionService.streamChat).not.toHaveBeenCalled();
+ });
+
+ it('finishes the turn as completed when the reply is saved', async () => {
+ const { job, turnRecorderService } = buildJob();
+
+ await job.handle(jobData);
+
+ expect(turnRecorderService.finish).toHaveBeenCalledWith({
+ workspaceId: 'workspace-id',
+ turnId: 'turn-id',
+ status: AgentTurnStatus.COMPLETED,
+ error: null,
+ modelId: 'openai/gpt-5.6-luna',
+ streamClaim: { threadId: 'thread-id', streamId: 'stream-id' },
+ });
+ });
+
it('runs a job queued before sender attribution with only its turn', async () => {
const { job, actorService, agentChatService } = buildJob();
await job.handle({ ...jobData, messageId: undefined });
@@ -433,18 +505,14 @@ describe('StreamAgentChatJob', () => {
});
it('does not invoke the model when the saved sender lost access before execution', async () => {
- const { job, actorService, chatExecutionService, threadRepository } =
+ const { job, actorService, chatExecutionService, claimReleases } =
buildJob();
actorService.authorizeJob.mockRejectedValue(
new Error('Sender access revoked'),
);
await expect(job.handle(jobData)).rejects.toThrow('Sender access revoked');
expect(chatExecutionService.streamChat).not.toHaveBeenCalled();
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- { activeStreamId: null },
- );
+ expect(claimReleases()).toContainEqual({ turnError: null });
});
it('publishes all chunks in order with message-persisted last on success', async () => {
@@ -454,6 +522,7 @@ describe('StreamAgentChatJob', () => {
threadRepository,
agentChatService,
agentChatStreamingService,
+ claimReleases,
} = buildJob();
await job.handle(jobData);
@@ -481,11 +550,7 @@ describe('StreamAgentChatJob', () => {
'workspace-id',
expect.any(Function),
);
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- { activeStreamId: null },
- );
+ expect(claimReleases()).toContainEqual({ turnError: null });
expect(agentChatStreamingService.flushNextQueuedMessage).toHaveBeenCalled();
});
@@ -529,7 +594,7 @@ describe('StreamAgentChatJob', () => {
outputTokenDetails: { textTokens: 2_000, reasoningTokens: 0 },
totalTokens: 302_000,
};
- const { job, threadUsageQuery } = buildJob({
+ const { job, turnRecorderService } = buildJob({
chatStream: createFakeChatStream({
parts: [
...START_PARTS,
@@ -556,8 +621,12 @@ describe('StreamAgentChatJob', () => {
await job.handle(jobData);
- const [, [, , inputTokens, outputTokens, inputCredits, outputCredits]] =
- threadUsageQuery.mock.calls[0] as unknown as [string, number[]];
+ expect(turnRecorderService.recordUsage).toHaveBeenCalledTimes(1);
+
+ const [{ usage }] = turnRecorderService.recordUsage.mock.calls[0] as [
+ { usage: Record<string, number> },
+ ];
+ const { inputTokens, outputTokens, inputCredits, outputCredits } = usage;
expect({ inputTokens, outputTokens, inputCredits, outputCredits }).toEqual({
inputTokens: 300_000,
@@ -593,7 +662,7 @@ describe('StreamAgentChatJob', () => {
});
it('rejects, persists the error, and unblocks the thread when the model stream fails mid-stream', async () => {
- const { job, publishedEvents, threadRepository } = buildJob({
+ const { job, publishedEvents, claimReleases } = buildJob({
chatStream: createFakeChatStream({
midStreamError: new Error('provider exploded'),
}),
@@ -617,26 +686,17 @@ describe('StreamAgentChatJob', () => {
expect(publishedEvents.map((event) => event.type)).not.toContain(
'message-persisted',
);
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- {
- activeStreamId: null,
- lastStreamError: expect.objectContaining({
- code: 'STREAM_EXECUTION_FAILED',
- message: 'provider exploded',
- }),
- },
- );
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- { activeStreamId: null },
- );
+ expect(claimReleases()).toContainEqual({
+ turnError: expect.objectContaining({
+ code: 'STREAM_EXECUTION_FAILED',
+ message: 'provider exploded',
+ }),
+ });
+ expect(claimReleases()).toContainEqual({ turnError: null });
});
it('rejects promptly when execution setup throws instead of hanging until the queue lock expires', async () => {
- const { job, publishedEvents, threadRepository } = buildJob({
+ const { job, publishedEvents, claimReleases } = buildJob({
streamChatRejection: new Error('model resolution failed'),
});
@@ -651,11 +711,7 @@ describe('StreamAgentChatJob', () => {
expect(publishedEvents[publishedEvents.length - 1]).toMatchObject({
type: 'queue-updated',
});
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- { activeStreamId: null },
- );
+ expect(claimReleases()).toContainEqual({ turnError: null });
});
it('terminates the stream with an error when assistant persistence fails after draining chunks', async () => {
@@ -682,7 +738,7 @@ describe('StreamAgentChatJob', () => {
});
it('persists the error and unblocks the thread when the workspace is missing', async () => {
- const { job, publishedEvents, threadRepository } = buildJob({
+ const { job, publishedEvents, claimReleases } = buildJob({
workspaceFound: false,
});
@@ -697,21 +753,12 @@ describe('StreamAgentChatJob', () => {
expect(publishedEvents[publishedEvents.length - 1]).toMatchObject({
type: 'queue-updated',
});
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- {
- activeStreamId: null,
- lastStreamError: expect.objectContaining({
- code: AiExceptionCode.WORKSPACE_NOT_FOUND,
- }),
- },
- );
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- { activeStreamId: null },
- );
+ expect(claimReleases()).toContainEqual({
+ turnError: expect.objectContaining({
+ code: AiExceptionCode.WORKSPACE_NOT_FOUND,
+ }),
+ });
+ expect(claimReleases()).toContainEqual({ turnError: null });
});
it('bails out without streaming when the thread no longer holds the claim for this stream', async () => {
@@ -755,16 +802,12 @@ describe('StreamAgentChatJob', () => {
it('persists the interrupted error and publishes the terminal sequence when aborted by a worker shutdown', async () => {
let triggerShutdown: (() => void) | undefined;
- const {
- job,
- publishedEvents,
- threadRepository,
- agentChatStreamingService,
- } = buildJob({
- chatStream: createFakeChatStream({
- onFirstPart: () => triggerShutdown?.(),
- }),
- });
+ const { job, publishedEvents, agentChatStreamingService, claimReleases } =
+ buildJob({
+ chatStream: createFakeChatStream({
+ onFirstPart: () => triggerShutdown?.(),
+ }),
+ });
const shutdownController = new AbortController();
@@ -784,21 +827,12 @@ describe('StreamAgentChatJob', () => {
});
expect(queueUpdatedIndex).toBeGreaterThan(streamErrorIndex);
expect(eventTypes).not.toContain('message-persisted');
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- {
- activeStreamId: null,
- lastStreamError: expect.objectContaining({
- code: AiExceptionCode.STREAM_INTERRUPTED,
- }),
- },
- );
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- { activeStreamId: null },
- );
+ expect(claimReleases()).toContainEqual({
+ turnError: expect.objectContaining({
+ code: AiExceptionCode.STREAM_INTERRUPTED,
+ }),
+ });
+ expect(claimReleases()).toContainEqual({ turnError: null });
expect(
agentChatStreamingService.flushNextQueuedMessage,
).not.toHaveBeenCalled();
@@ -914,7 +948,7 @@ describe('StreamAgentChatJob', () => {
});
const pendingQuestionMessageIdOf = (threadUsageQuery: jest.Mock) =>
- (threadUsageQuery.mock.calls[0] as unknown as [string, unknown[]])[1][10];
+ (threadUsageQuery.mock.calls[0] as unknown as [string, unknown[]])[1][4];
it('marks the conversation as waiting on the message that paused, in the totals write, and leaves the queue waiting', async () => {
const { job, threadUsageQuery, agentChatStreamingService } = buildJob({
@@ -1003,7 +1037,7 @@ describe('StreamAgentChatJob', () => {
});
it('adds the steps an aborted turn completed to the thread totals', async () => {
- const { job, threadUsageQuery } = buildJob({
+ const { job, turnRecorderService } = buildJob({
chatStream: createFakeChatStream({
parts: [
...START_PARTS,
@@ -1018,8 +1052,10 @@ describe('StreamAgentChatJob', () => {
await job.handle(jobData);
- const [, [, , inputTokens, outputTokens]] = threadUsageQuery.mock
- .calls[0] as unknown as [string, number[]];
+ const [{ usage }] = turnRecorderService.recordUsage.mock.calls[0] as [
+ { usage: Record<string, number> },
+ ];
+ const { inputTokens, outputTokens } = usage;
expect({ inputTokens, outputTokens }).toEqual({
inputTokens: 12,
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 f0efc3f1bad..7f018d7d76a 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
@@ -2,6 +2,9 @@ import { AgentChatActorService } from 'src/engine/metadata-modules/ai/ai-chat/se
import { findAwaitingCallText } from 'src/engine/metadata-modules/ai/ai-chat/utils/find-awaiting-call-text.util';
import { findLastMessageText } from 'src/engine/metadata-modules/ai/ai-chat/utils/find-last-message-text.util';
import { updateAgentChatThreadUsage } from 'src/engine/metadata-modules/ai/ai-chat/utils/update-agent-chat-thread-usage.util';
+import { mapAgentChatTurnOutcomeToTurnStatus } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-agent-chat-turn-outcome-to-turn-status.util';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
+import { buildActorMetadataFromAuthContext } from 'src/engine/core-modules/actor/utils/build-actor-metadata-from-auth-context.util';
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 { Logger, Scope } from '@nestjs/common';
@@ -30,9 +33,7 @@ import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service'
import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';
import { toDisplayCredits } from 'src/engine/core-modules/usage/utils/to-display-credits.util';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
-import { computeStepCostBreakdown } from 'src/engine/metadata-modules/ai/ai-billing/utils/compute-step-cost-breakdown.util';
-import { convertDollarsToCreditsMicro } from 'src/engine/metadata-modules/ai/ai-billing/utils/convert-dollars-to-credits-micro.util';
-import { extractCacheCreationTokens } from 'src/engine/metadata-modules/ai/ai-billing/utils/extract-cache-creation-tokens.util';
+import { addStepToAgentTurnUsage } from 'src/engine/metadata-modules/ai/ai-billing/utils/compute-agent-turn-usage-from-steps.util';
import {
AiException,
AiExceptionCode,
@@ -108,6 +109,7 @@ export class StreamAgentChatJob {
private readonly aiModelRegistryService: AiModelRegistryService,
private readonly actorService: AgentChatActorService,
private readonly sharingService: AgentChatSharingService,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
@Process(STREAM_AGENT_CHAT_JOB_NAME)
@@ -199,6 +201,19 @@ export class StreamAgentChatJob {
);
}
+ const isRunning = await this.turnRecorderService.markRunning({
+ workspaceId: data.workspaceId,
+ turnId,
+ modelId: turnModelId,
+ createdBy: buildActorMetadataFromAuthContext(authorization.authContext),
+ streamClaim: { threadId: data.threadId, streamId: data.streamId },
+ });
+
+ // the stream was stopped while starting, and its turn already ended
+ if (!isRunning) {
+ return;
+ }
+
const titlePromise = data.hasTitle
? Promise.resolve(null)
: this.agentChatService
@@ -634,25 +649,10 @@ export class StreamAgentChatJob {
usageTotals: StreamUsageTotals;
}) {
if (part.type === 'finish-step') {
- const stepCacheCreationTokens = extractCacheCreationTokens(
- part.providerMetadata,
+ Object.assign(
+ usageTotals,
+ addStepToAgentTurnUsage(modelConfig, usageTotals, part),
);
- const stepBreakdown = computeStepCostBreakdown(modelConfig, {
- usage: part.usage,
- cacheCreationTokens: stepCacheCreationTokens,
- });
-
- usageTotals.inputTokens += stepBreakdown.tokenCounts.totalInputTokens;
- usageTotals.outputTokens += part.usage?.outputTokens ?? 0;
- usageTotals.inputCredits += convertDollarsToCreditsMicro(
- stepBreakdown.inputCostInDollars,
- );
- usageTotals.outputCredits += convertDollarsToCreditsMicro(
- stepBreakdown.outputCostInDollars,
- );
- usageTotals.cacheReadTokens +=
- stepBreakdown.tokenCounts.cachedInputTokens;
- usageTotals.cacheCreationTokens += stepCacheCreationTokens;
usageTotals.conversationSize = part.usage?.inputTokens ?? 0;
}
@@ -734,6 +734,8 @@ export class StreamAgentChatJob {
});
}
+ await this.recordTurnUsage({ workspaceId, threadId, turnId, usageTotals });
+
if (isDefined(streamError)) {
return null;
}
@@ -746,6 +748,15 @@ export class StreamAgentChatJob {
});
if (responseMessage.parts.length === 0) {
+ await this.finishTurn({
+ workspaceId,
+ turnId,
+ threadId,
+ streamId,
+ outcome,
+ turnModelId,
+ });
+
return outcome;
}
@@ -774,12 +785,6 @@ export class StreamAgentChatJob {
? { lastMessageText: replyText }
: null,
usage: {
- totalInputTokens: usageTotals.inputTokens,
- totalOutputTokens: usageTotals.outputTokens,
- totalInputCredits: usageTotals.inputCredits,
- totalOutputCredits: usageTotals.outputCredits,
- totalCacheReadTokens: usageTotals.cacheReadTokens,
- totalCacheCreationTokens: usageTotals.cacheCreationTokens,
contextWindowTokens: modelConfig.contextWindowTokens,
conversationSize: usageTotals.conversationSize,
pendingQuestionMessageId: isAwaitingAnswer ? assistantMessageId : null,
@@ -809,6 +814,15 @@ export class StreamAgentChatJob {
this.isAwaitingInput = isAwaitingAnswer;
+ await this.finishTurn({
+ workspaceId,
+ turnId,
+ threadId,
+ streamId,
+ outcome,
+ turnModelId,
+ });
+
await this.agentChatService.notifyThreadUsageUpdated({
threadBefore: threadBeforeUsage,
workspaceMemberId,
@@ -818,6 +832,63 @@ export class StreamAgentChatJob {
return outcome;
}
+ // Usage is recorded on its own: a failure to count it must not fail a reply already saved
+ private async recordTurnUsage({
+ workspaceId,
+ threadId,
+ turnId,
+ usageTotals,
+ }: {
+ workspaceId: string;
+ threadId: string;
+ turnId: string;
+ usageTotals: StreamUsageTotals;
+ }): Promise<void> {
+ await this.turnRecorderService
+ .recordUsage({
+ workspaceId,
+ threadId,
+ turnId,
+ usage: {
+ inputTokens: usageTotals.inputTokens,
+ outputTokens: usageTotals.outputTokens,
+ cacheReadTokens: usageTotals.cacheReadTokens,
+ cacheCreationTokens: usageTotals.cacheCreationTokens,
+ inputCredits: usageTotals.inputCredits,
+ outputCredits: usageTotals.outputCredits,
+ },
+ })
+ .catch((error: unknown) =>
+ this.logger.warn(
+ `Could not record the usage of turn ${turnId}: ${formatErrorWithCause(error)}`,
+ ),
+ );
+ }
+
+ private async finishTurn({
+ workspaceId,
+ turnId,
+ threadId,
+ streamId,
+ outcome,
+ turnModelId,
+ }: {
+ workspaceId: string;
+ turnId: string;
+ threadId: string;
+ streamId: string;
+ outcome: AgentChatTurnOutcome;
+ turnModelId: string;
+ }): Promise<void> {
+ await this.turnRecorderService.finish({
+ workspaceId,
+ turnId,
+ ...mapAgentChatTurnOutcomeToTurnStatus(outcome),
+ modelId: turnModelId,
+ streamClaim: { threadId, streamId },
+ });
+ }
+
private logAssistantTurnWithoutText({
responseMessage,
isAborted,
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 f2b67b4a35c..65cb75ecdd9 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
@@ -114,6 +114,7 @@ const buildResolver = () => {
{ assertAiExecutionAllowed: jest.fn() } as never,
),
threadLifecycle,
+ { findLatestTurnError: jest.fn().mockResolvedValue(null) } as never,
);
return {
resolver,
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 fa36ffad55e..83d29f436c3 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
@@ -47,6 +47,7 @@ import { BillingGraphqlApiExceptionFilter } from 'src/engine/core-modules/billin
import { UsageLimitGraphqlApiExceptionFilter } from 'src/engine/core-modules/usage-limit/filters/usage-limit-graphql-api-exception.filter';
import { AiGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/ai/interceptors/ai-graphql-api-exception.interceptor';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
@UseGuards(
AuthPrincipalGuard({
@@ -80,6 +81,7 @@ export class AgentChatResolver {
private readonly systemPromptBuilderService: SystemPromptBuilderService,
private readonly turnPreflightService: AgentChatTurnPreflightService,
private readonly threadLifecycleService: AgentChatThreadLifecycleService,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
@Query(() => AgentChatThreadDTO)
@@ -128,14 +130,16 @@ export class AgentChatResolver {
const { chunks, maxSeq } =
await this.eventPublisherService.getAccumulatedChunks(threadId);
+ const turnError = await this.turnRecorderService.findLatestTurnError({
+ workspaceId,
+ threadId,
+ });
+
return {
chunks,
maxSeq,
- error: thread.lastStreamError
- ? {
- code: thread.lastStreamError.code,
- message: thread.lastStreamError.message,
- }
+ error: turnError
+ ? { code: turnError.code, message: turnError.message }
: null,
};
}
@@ -377,7 +381,7 @@ export class AgentChatResolver {
return toDisplayCredits(Number(thread.totalOutputCredits));
}
- // the caller reads the thread after this, so it sees the reaped stream as failed
+ // the caller reads the thread after this, so it sees the reaped stream as released
private async reapDeadStream(
thread: AgentChatThreadWorkspaceEntity,
workspaceId: string,
@@ -389,7 +393,6 @@ export class AgentChatResolver {
if (isDefined(interruptedError)) {
thread.activeStreamId = null;
- thread.lastStreamError = interruptedError;
}
}
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.claim.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.claim.spec.ts
index 1899e2e419a..c30e155de99 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.claim.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.claim.spec.ts
@@ -21,7 +21,6 @@ describe('AgentChatStreamingService claim & reap', () => {
title: 'Thread',
conversationSize: 0,
activeStreamId: null,
- lastStreamError: null,
};
const sendArguments = {
@@ -48,10 +47,34 @@ describe('AgentChatStreamingService claim & reap', () => {
heartbeatAlive?: boolean;
} = {}) => {
const publishedEvents: Array<{ type: string }> = [];
+ const releaseQuery = jest.fn(async (_sql: string, _parameters: unknown[]) =>
+ Array.from({ length: claimAffected }, () => ({ id: 'thread-id' })),
+ );
+ const claimReleases = () =>
+ releaseQuery.mock.calls.map(([, parameters]) => {
+ const [threadId, streamId, , turnError] = parameters as [
+ string,
+ string,
+ string | null,
+ string | null,
+ ];
+
+ return {
+ threadId,
+ streamId,
+ turnError: turnError === null ? null : JSON.parse(turnError),
+ };
+ });
const threadRepository = {
findOne: jest.fn().mockResolvedValue(thread),
findOneOrFail: jest.fn().mockResolvedValue(thread),
update: jest.fn().mockResolvedValue({ affected: claimAffected }),
+ query: jest.fn().mockImplementation(async (_workspaceId, work) =>
+ work({
+ table: (name: string) => name,
+ manager: { query: releaseQuery },
+ }),
+ ),
};
const messageQueueService = { add: jest.fn().mockResolvedValue(undefined) };
const agentChatService = {
@@ -125,11 +148,16 @@ describe('AgentChatStreamingService claim & reap', () => {
}),
} as never,
messagePartRepository as never,
+ {
+ findLatestTurn: jest.fn().mockResolvedValue(null),
+ markRunning: jest.fn().mockResolvedValue(true),
+ } as never,
);
return {
service,
streamRecoveryService,
+ claimReleases,
send: (overrides: { userWorkspaceId?: string } = {}) =>
service.streamAgentChat({
...sendArguments,
@@ -183,7 +211,7 @@ describe('AgentChatStreamingService claim & reap', () => {
expect(threadRepository.update).toHaveBeenCalledWith(
'workspace-id',
expect.objectContaining({ id: 'thread-id' }),
- expect.objectContaining({ lastStreamError: null }),
+ { activeStreamId: expect.any(String) },
);
expect(streamHeartbeatService.markClaimed).toHaveBeenCalled();
expect(
@@ -273,7 +301,7 @@ describe('AgentChatStreamingService claim & reap', () => {
it('releases the claim when enqueueing the job fails', async () => {
const {
send,
- threadRepository,
+ claimReleases,
messageQueueService,
streamHeartbeatService,
} = buildService();
@@ -282,11 +310,13 @@ describe('AgentChatStreamingService claim & reap', () => {
await expect(send()).rejects.toThrow('redis down');
- expect(threadRepository.update).toHaveBeenLastCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: expect.any(String) },
- { activeStreamId: null },
- );
+ expect(claimReleases()).toEqual([
+ {
+ threadId: 'thread-id',
+ streamId: expect.any(String),
+ turnError: expect.objectContaining({ message: 'redis down' }),
+ },
+ ]);
expect(streamHeartbeatService.clear).toHaveBeenCalled();
});
});
@@ -350,7 +380,7 @@ describe('AgentChatStreamingService claim & reap', () => {
it('converts a heartbeat-less claim into a retryable interrupted error', async () => {
const {
streamRecoveryService,
- threadRepository,
+ claimReleases,
eventPublisherService,
publishedEvents,
} = buildService({ heartbeatAlive: false });
@@ -363,16 +393,15 @@ describe('AgentChatStreamingService claim & reap', () => {
expect(reaped).toEqual(
expect.objectContaining({ code: AiExceptionCode.STREAM_INTERRUPTED }),
);
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: 'stream-id' },
- expect.objectContaining({
- activeStreamId: null,
- lastStreamError: expect.objectContaining({
+ expect(claimReleases()).toEqual([
+ {
+ threadId: 'thread-id',
+ streamId: 'stream-id',
+ turnError: expect.objectContaining({
code: AiExceptionCode.STREAM_INTERRUPTED,
}),
- }),
- );
+ },
+ ]);
expect(eventPublisherService.resetStreamState).toHaveBeenCalledWith(
'thread-id',
);
@@ -385,7 +414,7 @@ describe('AgentChatStreamingService claim & reap', () => {
});
it('does nothing when the claim moved to a newer stream mid-check', async () => {
- const { streamRecoveryService, publishedEvents, threadRepository } =
+ const { streamRecoveryService, publishedEvents, claimReleases } =
buildService({
heartbeatAlive: false,
claimAffected: 0,
@@ -397,7 +426,7 @@ describe('AgentChatStreamingService claim & reap', () => {
});
expect(reaped).toBeNull();
- expect(threadRepository.update).toHaveBeenCalledTimes(1);
+ expect(claimReleases()).toHaveLength(1);
expect(publishedEvents).toHaveLength(0);
});
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.opening-turn.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.opening-turn.spec.ts
index 00cd075e2e9..f2b9785bb87 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.opening-turn.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.opening-turn.spec.ts
@@ -11,13 +11,21 @@ describe('AgentChatStreamingService.startOpeningTurn', () => {
title: 'Workspace setup',
conversationSize: 0,
activeStreamId: null,
- lastStreamError: null,
} as unknown as AgentChatThreadWorkspaceEntity;
const buildService = ({ claimAffected = 1, hasMessages = false } = {}) => {
+ const releaseQuery = jest.fn(
+ async (_sql: string, _parameters: unknown[]) => [{ id: 'thread-id' }],
+ );
const threadRepository = {
findOne: jest.fn().mockResolvedValue(thread),
update: jest.fn().mockResolvedValue({ affected: claimAffected }),
+ query: jest.fn().mockImplementation(async (_workspaceId, work) =>
+ work({
+ table: (name: string) => name,
+ manager: { query: releaseQuery },
+ }),
+ ),
};
const messageQueueService = { add: jest.fn().mockResolvedValue(undefined) };
const agentChatService = {
@@ -59,10 +67,12 @@ describe('AgentChatStreamingService.startOpeningTurn', () => {
),
{} as never,
{} as never,
+ {} as never,
);
return {
service,
+ releaseQuery,
threadRepository,
messageQueueService,
agentChatService,
@@ -98,7 +108,7 @@ describe('AgentChatStreamingService.startOpeningTurn', () => {
});
it('releases the claim and flushes the queue when the conversation already started', async () => {
- const { service, threadRepository, agentChatService, messageQueueService } =
+ const { service, releaseQuery, agentChatService, messageQueueService } =
buildService({ hasMessages: true });
const result = await service.startOpeningTurn(openingTurnArguments);
@@ -106,10 +116,9 @@ describe('AgentChatStreamingService.startOpeningTurn', () => {
expect(result).toBeNull();
expect(agentChatService.replaceOpeningTurn).not.toHaveBeenCalled();
expect(messageQueueService.add).not.toHaveBeenCalled();
- expect(threadRepository.update).toHaveBeenCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: expect.any(String) },
- { activeStreamId: null },
+ expect(releaseQuery).toHaveBeenCalledWith(
+ expect.stringContaining('"activeStreamId" = NULL'),
+ ['thread-id', expect.any(String), null, null],
);
expect(agentChatService.getQueuedMessages).toHaveBeenCalledWith({
threadId: 'thread-id',
@@ -161,14 +170,14 @@ describe('AgentChatStreamingService.startOpeningTurn', () => {
expect(threadRepository.update).toHaveBeenCalledWith(
'workspace-id',
expect.objectContaining({ id: 'thread-id' }),
- { activeStreamId: result?.streamId, lastStreamError: null },
+ { activeStreamId: result?.streamId },
);
});
it('releases the claim and reports an enqueue failure when adding the job fails', async () => {
const {
service,
- threadRepository,
+ releaseQuery,
messageQueueService,
streamHeartbeatService,
metricsService,
@@ -180,10 +189,14 @@ describe('AgentChatStreamingService.startOpeningTurn', () => {
service.startOpeningTurn(openingTurnArguments),
).rejects.toThrow('redis down');
- expect(threadRepository.update).toHaveBeenLastCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: expect.any(String) },
- { activeStreamId: null },
+ expect(releaseQuery).toHaveBeenLastCalledWith(
+ expect.stringContaining('"activeStreamId" = NULL'),
+ [
+ 'thread-id',
+ expect.any(String),
+ 'failed',
+ expect.stringContaining('redis down'),
+ ],
);
expect(streamHeartbeatService.clear).toHaveBeenCalled();
expect(metricsService.incrementCounterBy).toHaveBeenCalledWith(
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.retry.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.retry.spec.ts
index 841bcccb75e..e21ea7c0ce2 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.retry.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat-streaming.service.retry.spec.ts
@@ -1,5 +1,6 @@
import { AgentChatStreamRecoveryService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-recovery.service';
import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
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';
@@ -15,13 +16,14 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
title: 'Thread title',
conversationSize: 42,
activeStreamId: null,
- lastStreamError: {
- code: 'STREAM_EXECUTION_FAILED',
- message: 'Provider timed out',
- failedAt: '2026-01-01T00:00:00.000Z',
- },
} as unknown as AgentChatThreadWorkspaceEntity;
+ const failedTurn = {
+ id: 'turn-id',
+ status: AgentTurnStatus.FAILED,
+ error: { code: 'STREAM_EXECUTION_FAILED', message: 'Provider timed out' },
+ };
+
const userMessageEntity = {
id: 'user-message-id',
role: AgentMessageRole.USER,
@@ -32,19 +34,32 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
const buildService = ({
thread = failedThread,
+ latestTurn = failedTurn as typeof failedTurn | null,
turnUserMessage = { id: 'user-message-id' } as { id: string } | null,
threadMessages = [userMessageEntity],
} = {}) => {
+ const claimQuery = jest.fn(async (_sql: string, _parameters: unknown[]) => [
+ { id: 'thread-id' },
+ ]);
const threadRepository = {
findOneOrFail: jest
.fn()
.mockResolvedValue({ workspaceMemberId: 'member' }),
findOne: jest.fn().mockResolvedValue(thread),
update: jest.fn().mockResolvedValue({ affected: 1 }),
+ query: jest.fn().mockImplementation(async (_workspaceId, work) =>
+ work({
+ table: (name: string) => name,
+ manager: { query: claimQuery },
+ }),
+ ),
+ };
+ const turnRecorderService = {
+ findLatestTurn: jest.fn().mockResolvedValue(latestTurn),
+ markRunning: jest.fn().mockResolvedValue(true),
};
const messageQueueService = { add: jest.fn().mockResolvedValue(undefined) };
const agentChatService = {
- findLatestTurnId: jest.fn().mockResolvedValue('turn-id'),
deleteAssistantMessagesForTurn: jest.fn().mockResolvedValue(undefined),
getMessagesForThread: jest.fn().mockResolvedValue(threadMessages),
getThreadContexts: jest.fn().mockResolvedValue([]),
@@ -94,10 +109,13 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
hasPendingForThread: jest.fn().mockResolvedValue(false),
cancel: jest.fn().mockResolvedValue(false),
} as never,
+ turnRecorderService as never,
);
return {
service,
+ claimQuery,
+ turnRecorderService,
threadRepository,
messageQueueService,
agentChatService,
@@ -138,9 +156,9 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
expect(messageQueueService.add).not.toHaveBeenCalled();
});
- it('rejects when the thread has no persisted stream error', async () => {
+ it('rejects when the latest turn did not fail', async () => {
const { service, messageQueueService } = buildService({
- thread: { ...failedThread, lastStreamError: null },
+ latestTurn: { ...failedTurn, status: AgentTurnStatus.COMPLETED },
});
await expect(
@@ -164,9 +182,14 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
expect(messageQueueService.add).not.toHaveBeenCalled();
});
- it('drops the failed output, re-enqueues the turn, and clears the error', async () => {
- const { service, threadRepository, messageQueueService, agentChatService } =
- buildService();
+ it('drops the failed output, re-enqueues the turn, and runs it again', async () => {
+ const {
+ service,
+ threadRepository,
+ messageQueueService,
+ agentChatService,
+ turnRecorderService,
+ } = buildService();
const result = await service.retryLastFailedTurn({
...retryArguments,
@@ -190,8 +213,13 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
expect(threadRepository.update).toHaveBeenCalledWith(
'workspace-id',
expect.objectContaining({ id: 'thread-id' }),
- { activeStreamId: result.streamId, lastStreamError: null },
+ { activeStreamId: result.streamId },
);
+ expect(turnRecorderService.markRunning).toHaveBeenCalledWith({
+ workspaceId: 'workspace-id',
+ turnId: 'turn-id',
+ streamClaim: { threadId: 'thread-id', streamId: result.streamId },
+ });
expect(result.messageId).toBe('user-message-id');
expect(result.turnId).toBe('turn-id');
});
@@ -227,11 +255,16 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
});
it('does not delete another participant’s output if the latest turn changes while claiming a retry', async () => {
- const { service, agentChatService, messageQueueService, threadRepository } =
- buildService();
- agentChatService.findLatestTurnId
- .mockResolvedValueOnce('turn-id')
- .mockResolvedValueOnce('another-turn');
+ const {
+ service,
+ agentChatService,
+ messageQueueService,
+ claimQuery,
+ turnRecorderService,
+ } = buildService();
+ turnRecorderService.findLatestTurn
+ .mockResolvedValueOnce(failedTurn)
+ .mockResolvedValueOnce({ ...failedTurn, id: 'another-turn' });
await expect(
service.retryLastFailedTurn(retryArguments),
).rejects.toMatchObject({ code: AiExceptionCode.NO_FAILED_TURN_TO_RETRY });
@@ -239,13 +272,16 @@ describe('AgentChatStreamingService.retryLastFailedTurn', () => {
agentChatService.deleteAssistantMessagesForTurn,
).not.toHaveBeenCalled();
expect(messageQueueService.add).not.toHaveBeenCalled();
- expect(threadRepository.update).toHaveBeenLastCalledWith(
- 'workspace-id',
- { id: 'thread-id', activeStreamId: expect.any(String) },
- {
- activeStreamId: null,
- lastStreamError: failedThread.lastStreamError,
- },
- );
+ expect(turnRecorderService.markRunning).not.toHaveBeenCalled();
+
+ const [releaseSql, releaseParameters] = claimQuery.mock.calls[
+ claimQuery.mock.calls.length - 1
+ ] as [string, unknown[]];
+
+ expect(releaseSql).toContain('"activeStreamId" = NULL');
+ expect(releaseParameters.slice(0, 2)).toEqual([
+ 'thread-id',
+ expect.any(String),
+ ]);
});
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.close-pending-tool-calls.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.close-pending-tool-calls.spec.ts
index f1681665f49..021c81e0a29 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.close-pending-tool-calls.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-chat.service.close-pending-tool-calls.spec.ts
@@ -1,5 +1,6 @@
import { IsNull } from 'typeorm';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
import { AgentChatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat.service';
const QUESTIONS = [
@@ -23,6 +24,9 @@ const buildService = ({ claimAffected = 1 } = {}) => {
const threadRecordEventService = {
emitThreadUpdated: jest.fn().mockResolvedValue(undefined),
};
+ const turnRecorderService = {
+ endWaitingTurn: jest.fn().mockResolvedValue(undefined),
+ };
const messagePartRepository = {
find: jest.fn().mockResolvedValue([
{
@@ -54,6 +58,7 @@ const buildService = ({ claimAffected = 1 } = {}) => {
threadRecordEventService as never,
{} as never,
{} as never,
+ turnRecorderService as never,
);
return {
@@ -61,6 +66,7 @@ const buildService = ({ claimAffected = 1 } = {}) => {
threadRepository,
messagePartRepository,
threadRecordEventService,
+ turnRecorderService,
};
};
@@ -73,10 +79,21 @@ const closeArguments = {
describe('AgentChatService closePendingToolCalls', () => {
it('stops waiting and closes the pending call as skipped', async () => {
- const { service, threadRepository, messagePartRepository } = buildService();
+ const {
+ service,
+ threadRepository,
+ messagePartRepository,
+ turnRecorderService,
+ } = buildService();
await service.closePendingToolCalls(closeArguments);
+ expect(turnRecorderService.endWaitingTurn).toHaveBeenCalledWith({
+ workspaceId: 'workspace-id',
+ messageId: 'question-message-id',
+ status: AgentTurnStatus.COMPLETED,
+ });
+
expect(threadRepository.update).toHaveBeenCalledWith(
'workspace-id',
{
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 aaa15452406..64f09699ae1 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
@@ -6,10 +6,14 @@ import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.
import { AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
import { AgentChatEventPublisherService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-event-publisher.service';
import { AgentChatStreamHeartbeatService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-stream-heartbeat.service';
-import { type AgentChatThreadLastStreamError } from 'src/engine/metadata-modules/ai/ai-chat/types/agent-chat-thread-last-stream-error.type';
import { formatErrorWithCause } from 'src/engine/metadata-modules/ai/ai-chat/utils/format-error-with-cause.util';
-import { mapErrorToStreamError } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
+import {
+ mapErrorToStreamError,
+ type StreamErrorPayload,
+} from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
+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 { buildReleaseStreamClaimQuery } from 'src/engine/metadata-modules/ai/ai-history/utils/build-release-stream-claim-query.util';
import { AiExceptionCode } from 'src/engine/metadata-modules/ai/ai.exception';
import { InjectAgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/inject-agent-history-repository.decorator';
@@ -36,15 +40,15 @@ export class AgentChatStreamRecoveryService {
threadId,
workspaceId,
streamId,
- lastStreamError,
+ turnError,
}: AgentChatStreamClaim & {
- lastStreamError?: AgentChatThreadLastStreamError;
+ turnError?: StreamErrorPayload;
}): Promise<boolean> {
const isReleased = await this.clearStreamClaim({
threadId,
workspaceId,
streamId,
- lastStreamError,
+ turnError,
}).catch((error: unknown) => {
this.logger.error(
`Failed to release stream claim for thread ${threadId}: ${formatErrorWithCause(error)}`,
@@ -58,24 +62,32 @@ export class AgentChatStreamRecoveryService {
return isReleased;
}
+ // The error belongs to the turn the stream was running, and is only written
+ // by the caller still holding the claim
private async clearStreamClaim({
threadId,
workspaceId,
streamId,
- lastStreamError,
+ turnError,
}: AgentChatStreamClaim & {
- lastStreamError?: AgentChatThreadLastStreamError;
+ turnError?: StreamErrorPayload;
}): Promise<boolean> {
- const result = await this.threadRepository.update(
+ return this.threadRepository.query(
workspaceId,
- { id: threadId, activeStreamId: streamId },
- {
- activeStreamId: null,
- ...(isDefined(lastStreamError) ? { lastStreamError } : {}),
+ async ({ manager, table }) => {
+ const releasedThreads = await manager.query<{ id: string }[]>(
+ buildReleaseStreamClaimQuery({ table }),
+ [
+ threadId,
+ streamId,
+ isDefined(turnError) ? AgentTurnStatus.FAILED : null,
+ isDefined(turnError) ? JSON.stringify(turnError) : null,
+ ],
+ );
+
+ return releasedThreads.length > 0;
},
);
-
- return Boolean(result.affected);
}
async failStream({
@@ -84,20 +96,17 @@ export class AgentChatStreamRecoveryService {
streamId,
error,
}: AgentChatStreamClaim & { error: unknown }): Promise<void> {
- const lastStreamError: AgentChatThreadLastStreamError = {
- ...mapErrorToStreamError(error),
- failedAt: new Date().toISOString(),
- };
+ const turnError = mapErrorToStreamError(error);
const isReleased = await this.releaseStreamClaim({
threadId,
workspaceId,
streamId,
- lastStreamError,
+ turnError,
});
if (isReleased) {
- await this.publishStreamError({ threadId, workspaceId, lastStreamError });
+ await this.publishStreamError({ threadId, workspaceId, turnError });
}
}
@@ -107,7 +116,7 @@ export class AgentChatStreamRecoveryService {
}: {
thread: Pick<AgentChatThreadWorkspaceEntity, 'id' | 'activeStreamId'>;
workspaceId: string;
- }): Promise<AgentChatThreadLastStreamError | null> {
+ }): Promise<StreamErrorPayload | null> {
if (!isNonEmptyString(thread.activeStreamId)) {
return null;
}
@@ -116,17 +125,16 @@ export class AgentChatStreamRecoveryService {
return null;
}
- const interruptedError: AgentChatThreadLastStreamError = {
+ const interruptedError: StreamErrorPayload = {
code: AiExceptionCode.STREAM_INTERRUPTED,
message: 'The response was interrupted before it could finish.',
- failedAt: new Date().toISOString(),
};
const hasReaped = await this.clearStreamClaim({
threadId: thread.id,
workspaceId,
streamId: thread.activeStreamId,
- lastStreamError: interruptedError,
+ turnError: interruptedError,
});
if (!hasReaped) {
@@ -150,7 +158,7 @@ export class AgentChatStreamRecoveryService {
await this.publishStreamError({
threadId: thread.id,
workspaceId,
- lastStreamError: interruptedError,
+ turnError: interruptedError,
});
return interruptedError;
@@ -159,11 +167,11 @@ export class AgentChatStreamRecoveryService {
private async publishStreamError({
threadId,
workspaceId,
- lastStreamError,
+ turnError,
}: {
threadId: string;
workspaceId: string;
- lastStreamError: AgentChatThreadLastStreamError;
+ turnError: StreamErrorPayload;
}): Promise<void> {
await this.eventPublisherService
.publish({
@@ -171,8 +179,8 @@ export class AgentChatStreamRecoveryService {
workspaceId,
event: {
type: 'stream-error',
- code: lastStreamError.code,
- message: lastStreamError.message,
+ code: turnError.code,
+ message: turnError.message,
},
})
.catch(() => {});
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 9008d9f4bde..4e89c635028 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
@@ -19,7 +19,7 @@ import {
} from 'twenty-shared/ai';
import { FileFolder } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
-import { type FindOptionsWhere, In, IsNull, Like, Not } from 'typeorm';
+import { type FindOptionsWhere, In, IsNull, Like } from 'typeorm';
import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
import { FileUrlService } from 'src/engine/core-modules/file/file-url/file-url.service';
@@ -36,7 +36,6 @@ import { mapDBPartsToUIMessageParts } from 'src/engine/metadata-modules/ai/ai-ag
import { type BrowsingContextType } from 'src/engine/metadata-modules/ai/ai-agent/types/browsing-context.type';
import { AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
import { AgentMessagePartWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message-part.workspace-entity';
-import { type AgentChatThreadLastStreamError } from 'src/engine/metadata-modules/ai/ai-chat/types/agent-chat-thread-last-stream-error.type';
import { STREAM_AGENT_CHAT_JOB_NAME } from 'src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat-job-name.constant';
import { type StreamAgentChatJobData } from 'src/engine/metadata-modules/ai/ai-chat/jobs/stream-agent-chat-job.types';
import { AgentChatEventPublisherService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-event-publisher.service';
@@ -52,6 +51,8 @@ import {
} from 'src/engine/metadata-modules/ai/ai.exception';
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 { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
type StreamAgentChatOptions = {
thread: AgentChatThreadWorkspaceEntity;
@@ -91,6 +92,7 @@ export class AgentChatStreamingService {
private readonly actorService: AgentChatActorService,
@InjectAgentHistoryRepository('agentMessagePart')
private readonly messagePartRepository: AgentHistoryRepository<AgentMessagePartWorkspaceEntity>,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
async tryClaimStream({
@@ -106,7 +108,7 @@ export class AgentChatStreamingService {
const claim = await this.threadRepository.update(
workspaceId,
{ id: threadId, activeStreamId: IsNull(), ...where },
- { activeStreamId: streamId, lastStreamError: null },
+ { activeStreamId: streamId },
);
if (!claim.affected) {
@@ -315,24 +317,21 @@ export class AgentChatStreamingService {
workspaceMemberId,
workspaceId,
});
- const { lastStreamError } = thread;
-
- if (
- !isDefined(lastStreamError) ||
- isNonEmptyString(thread.activeStreamId)
- ) {
+ if (isNonEmptyString(thread.activeStreamId)) {
throw this.noFailedTurnToRetry();
}
- const turnId = await this.agentChatService.findLatestTurnId({
+ const latestTurn = await this.turnRecorderService.findLatestTurn({
threadId,
workspaceId,
});
- if (!isDefined(turnId)) {
+ if (latestTurn?.status !== AgentTurnStatus.FAILED) {
throw this.noFailedTurnToRetry();
}
+ const turnId = latestTurn.id;
+
const { message } = await this.actorService.authorizeRetry({
workspaceId,
threadId,
@@ -346,7 +345,6 @@ export class AgentChatStreamingService {
threadId,
workspaceId,
streamId,
- where: { lastStreamError: Not(IsNull()) },
});
if (!claimed) {
@@ -354,18 +352,31 @@ export class AgentChatStreamingService {
}
return this.releaseClaimOnEnqueueFailure(
- { threadId, workspaceId, streamId, modelId, lastStreamError },
+ { threadId, workspaceId, streamId, modelId },
async () => {
// the latest turn may have changed while claiming, and its output is not ours to delete
+ const claimedTurn = await this.turnRecorderService.findLatestTurn({
+ threadId,
+ workspaceId,
+ });
+
if (
- (await this.agentChatService.findLatestTurnId({
- threadId,
- workspaceId,
- })) !== turnId
+ claimedTurn?.id !== turnId ||
+ claimedTurn.status !== AgentTurnStatus.FAILED
) {
throw this.noFailedTurnToRetry();
}
+ const isRunning = await this.turnRecorderService.markRunning({
+ workspaceId,
+ turnId,
+ streamClaim: { threadId, streamId },
+ });
+
+ if (!isRunning) {
+ throw this.noFailedTurnToRetry();
+ }
+
await this.agentChatService.deleteAssistantMessagesForTurn({
turnId,
workspaceId,
@@ -678,22 +689,16 @@ export class AgentChatStreamingService {
}
private async releaseClaimOnEnqueueFailure<TResult>(
- {
- modelId,
- lastStreamError,
- ...claim
- }: AgentChatStreamClaim & {
- modelId?: string;
- lastStreamError?: AgentChatThreadLastStreamError;
- },
+ { modelId, ...claim }: AgentChatStreamClaim & { modelId?: string },
enqueue: () => Promise<TResult>,
): Promise<TResult> {
try {
return await enqueue();
} catch (error) {
+ // a turn the claim already started fails with the enqueue error
await this.streamRecoveryService.releaseStreamClaim({
...claim,
- lastStreamError,
+ turnError: mapErrorToStreamError(error),
});
const model = modelId ?? 'unknown';
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts
index 202c10460fe..37788d37587 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-lifecycle.service.ts
@@ -13,6 +13,8 @@ import { getCancelChannel } from 'src/engine/metadata-modules/ai/ai-chat/utils/g
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 { AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
@Injectable()
export class AgentChatThreadLifecycleService {
@@ -24,6 +26,7 @@ export class AgentChatThreadLifecycleService {
private readonly redisClientService: RedisClientService,
private readonly codeInterpreterService: CodeInterpreterService,
private readonly threadRecordEventService: AgentChatThreadRecordEventService,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
async cancelStream({
@@ -159,13 +162,14 @@ export class AgentChatThreadLifecycleService {
streamId: thread.activeStreamId,
});
- const { affected } = await this.threadRepository.update(
+ const isReleased = await this.turnRecorderService.releaseStreamClaim({
workspaceId,
- { id: thread.id, activeStreamId: thread.activeStreamId },
- { activeStreamId: null },
- );
+ threadId: thread.id,
+ streamId: thread.activeStreamId,
+ endRunningTurn: { status: AgentTurnStatus.CANCELLED },
+ });
- if (affected > 0) {
+ if (isReleased) {
await this.threadRecordEventService.emitThreadUpdated({
workspaceId,
threadBefore: thread,
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 90033a38b2a..458edc772ad 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,6 +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, Logger } from '@nestjs/common';
+import { type ActorMetadata } from 'twenty-shared/types';
import { ExtendedUIMessage } from 'twenty-shared/ai';
import {
@@ -18,6 +19,10 @@ import { AgentMessagePartWorkspaceEntity } from 'src/engine/metadata-modules/ai/
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 { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
+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 { mapUIMessagePartsToDBParts } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/map-ui-message-parts-to-db-parts.util';
import { findAwaitingPausingTool } from 'src/engine/metadata-modules/ai/ai-agent-execution/pausing-tools/utils/find-awaiting-pausing-tool.util';
@@ -53,6 +58,7 @@ export class AgentChatService {
private readonly threadRecordEventService: AgentChatThreadRecordEventService,
private readonly conversationWriterService: AgentConversationWriterService,
private readonly threadService: AgentChatThreadService,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
private getMessageSenderValues({
@@ -76,11 +82,30 @@ export class AgentChatService {
};
}
+ private getMessageSenderActor({
+ workspaceId,
+ userWorkspaceId,
+ }: {
+ workspaceId: string;
+ userWorkspaceId?: string;
+ }): ActorMetadata | undefined {
+ const context = workspaceAuthContextStorage.getStore();
+
+ return isDefined(context) &&
+ isUserAuthContext(context) &&
+ context.workspace.id === workspaceId &&
+ context.userWorkspaceId === userWorkspaceId
+ ? buildActorMetadataFromAuthContext(context)
+ : undefined;
+ }
+
+ // A message opening its own turn runs the agent unless the caller says nothing will
async addMessage({
threadId,
uiMessage,
agentId,
turnId,
+ turnStatus = AgentTurnStatus.RUNNING,
id,
workspaceId,
userWorkspaceId,
@@ -89,6 +114,7 @@ export class AgentChatService {
uiMessage: Omit<ExtendedUIMessage, 'id'>;
agentId?: string;
turnId?: string;
+ turnStatus?: AgentTurnStatus;
id?: string;
workspaceId: string;
userWorkspaceId?: string;
@@ -99,6 +125,8 @@ export class AgentChatService {
workspaceId,
threadId,
agentId: agentId ?? null,
+ status: turnStatus,
+ createdBy: this.getMessageSenderActor({ workspaceId, userWorkspaceId }),
}));
const senderValues = this.getMessageSenderValues({
@@ -169,22 +197,6 @@ export class AgentChatService {
);
}
- async findLatestTurnId({
- threadId,
- workspaceId,
- }: {
- threadId: string;
- workspaceId: string;
- }): Promise<string | null> {
- const latestTurn = await this.turnRepository.findOne(workspaceId, {
- where: { threadId },
- order: { createdAt: 'DESC', id: 'DESC' },
- select: ['id'],
- });
-
- return latestTurn?.id ?? null;
- }
-
// the contexts are the thread owner's, so the turns of other participants run without them
async getThreadContexts({
threadId,
@@ -471,6 +483,7 @@ export class AgentChatService {
workspaceId,
threadId,
agentId: null,
+ status: AgentTurnStatus.RUNNING,
});
const result = await this.messageRepository.update(
@@ -605,7 +618,16 @@ export class AgentChatService {
[threadId, messageId],
);
- return clearedThreads.length > 0;
+ if (clearedThreads.length === 0) {
+ return false;
+ }
+
+ await manager.query(buildEndWaitingAgentTurnQuery({ table }), [
+ messageId,
+ AgentTurnStatus.COMPLETED,
+ ]);
+
+ return true;
},
);
@@ -640,6 +662,12 @@ export class AgentChatService {
return;
}
+ await this.turnRecorderService.endWaitingTurn({
+ workspaceId,
+ messageId,
+ status: AgentTurnStatus.COMPLETED,
+ });
+
await closeOpenToolParts({
messagePartRepository: this.messagePartRepository,
messageId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts
index 6a6a7a0c2ca..c4f709dca68 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts
@@ -24,6 +24,7 @@ import { type AgentMessagePartWorkspaceEntity } from 'src/engine/metadata-module
import { type AgentMessageWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message.workspace-entity';
import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
@Injectable()
export class AgentInboxService {
@@ -267,6 +268,7 @@ export class AgentInboxService {
id: turnId,
threadId,
agentId: null,
+ status: AgentTurnStatus.COMPLETED,
}),
);
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/__tests__/map-agent-chat-turn-outcome-to-turn-status.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/__tests__/map-agent-chat-turn-outcome-to-turn-status.util.spec.ts
new file mode 100644
index 00000000000..2d670a18eec
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/__tests__/map-agent-chat-turn-outcome-to-turn-status.util.spec.ts
@@ -0,0 +1,56 @@
+import { mapAgentChatTurnOutcomeToTurnStatus } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-agent-chat-turn-outcome-to-turn-status.util';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+
+describe('mapAgentChatTurnOutcomeToTurnStatus', () => {
+ it('completes an answered turn', () => {
+ expect(
+ mapAgentChatTurnOutcomeToTurnStatus({
+ kind: 'completed',
+ outcome: 'answered',
+ }),
+ ).toEqual({ status: AgentTurnStatus.COMPLETED, error: null });
+ });
+
+ it('leaves a turn that asked a question waiting for its answer', () => {
+ expect(
+ mapAgentChatTurnOutcomeToTurnStatus({
+ kind: 'completed',
+ outcome: 'awaiting_user',
+ }),
+ ).toEqual({ status: AgentTurnStatus.WAITING_FOR_INPUT, error: null });
+ });
+
+ it('cancels a turn the member stopped', () => {
+ expect(
+ mapAgentChatTurnOutcomeToTurnStatus({
+ kind: 'cancelled',
+ reason: 'user_cancelled',
+ }),
+ ).toEqual({ status: AgentTurnStatus.CANCELLED, error: null });
+ });
+
+ it('fails a turn that ran out of credits with a readable error', () => {
+ expect(
+ mapAgentChatTurnOutcomeToTurnStatus({
+ kind: 'failed',
+ failurePhase: 'credits_exhausted',
+ }),
+ ).toEqual({
+ status: AgentTurnStatus.FAILED,
+ error: expect.objectContaining({ code: 'CREDITS_EXHAUSTED' }),
+ });
+ });
+
+ it('keeps the error code of a turn that failed while running', () => {
+ expect(
+ mapAgentChatTurnOutcomeToTurnStatus({
+ kind: 'failed',
+ failurePhase: 'execution',
+ errorCode: 'STREAM_INTERRUPTED',
+ }),
+ ).toEqual({
+ status: AgentTurnStatus.FAILED,
+ error: expect.objectContaining({ code: 'STREAM_INTERRUPTED' }),
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/map-agent-chat-turn-outcome-to-turn-status.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/map-agent-chat-turn-outcome-to-turn-status.util.ts
new file mode 100644
index 00000000000..46b6529c02b
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/map-agent-chat-turn-outcome-to-turn-status.util.ts
@@ -0,0 +1,50 @@
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { type AgentChatTurnOutcome } from 'src/engine/metadata-modules/ai/ai-chat/types/agent-chat-turn-outcome.type';
+import { type StreamErrorPayload } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
+import { AGENT_TURN_CREDITS_EXHAUSTED_ERROR } from 'src/engine/metadata-modules/ai/ai-history/constants/agent-turn-credits-exhausted-error.constant';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+
+const FAILURE_ERRORS: Record<
+ Exclude<
+ Extract<AgentChatTurnOutcome, { kind: 'failed' }>['failurePhase'],
+ 'execution'
+ >,
+ StreamErrorPayload
+> = {
+ no_text: {
+ code: 'NO_TEXT',
+ message: 'The agent stopped without replying.',
+ },
+ credits_exhausted: AGENT_TURN_CREDITS_EXHAUSTED_ERROR,
+};
+
+export const mapAgentChatTurnOutcomeToTurnStatus = (
+ outcome: AgentChatTurnOutcome,
+): { status: AgentTurnStatus; error: StreamErrorPayload | null } => {
+ switch (outcome.kind) {
+ case 'completed':
+ return {
+ status:
+ outcome.outcome === 'awaiting_user'
+ ? AgentTurnStatus.WAITING_FOR_INPUT
+ : AgentTurnStatus.COMPLETED,
+ error: null,
+ };
+ case 'cancelled':
+ return { status: AgentTurnStatus.CANCELLED, error: null };
+ case 'failed':
+ return {
+ status: AgentTurnStatus.FAILED,
+ error:
+ outcome.failurePhase === 'execution'
+ ? {
+ code: outcome.errorCode ?? 'EXECUTION_FAILED',
+ message: 'The agent failed while running.',
+ }
+ : FAILURE_ERRORS[outcome.failurePhase],
+ };
+ default:
+ return assertUnreachable(outcome);
+ }
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/update-agent-chat-thread-usage.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/update-agent-chat-thread-usage.util.ts
index 65970b66204..1d1802f37b4 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/update-agent-chat-thread-usage.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/utils/update-agent-chat-thread-usage.util.ts
@@ -5,12 +5,6 @@ import { AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/a
import { type AgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/agent-history-repository';
type ThreadUsageUpdate = {
- totalInputTokens: number;
- totalOutputTokens: number;
- totalInputCredits: number;
- totalOutputCredits: number;
- totalCacheReadTokens: number;
- totalCacheCreationTokens: number;
contextWindowTokens: number | null;
conversationSize: number;
pendingQuestionMessageId: string | null;
@@ -33,22 +27,15 @@ export const updateAgentChatThreadUsage = async ({
recordedActivity: { lastMessageText: string | null } | null;
}): Promise<{ affected: number }> =>
repository.query(workspaceId, async ({ manager, table }) => {
- // sum in Postgres: JS numbers must never be added to exact NUMERIC totals
const rows = await manager.query<{ id: string }[]>(
`
WITH updated AS (
UPDATE ${table('agentChatThread')} SET
- "totalInputTokens" = "totalInputTokens" + $3,
- "totalOutputTokens" = "totalOutputTokens" + $4,
- "totalInputCredits" = "totalInputCredits" + $5,
- "totalOutputCredits" = "totalOutputCredits" + $6,
- "totalCacheReadTokens" = "totalCacheReadTokens" + $7,
- "totalCacheCreationTokens" = "totalCacheCreationTokens" + $8,
- "contextWindowTokens" = $9, "conversationSize" = $10,
- "pendingQuestionMessageId" = $11, "lastStreamError" = NULL,
+ "contextWindowTokens" = $3, "conversationSize" = $4,
+ "pendingQuestionMessageId" = $5,
${
isDefined(recordedActivity)
- ? `${buildAgentChatThreadActivitySetClause({ textParameter: '$12' })},`
+ ? `${buildAgentChatThreadActivitySetClause({ textParameter: '$6' })},`
: ''
} "updatedAt" = now()
WHERE id = $1 AND "activeStreamId" = $2
@@ -57,12 +44,6 @@ export const updateAgentChatThreadUsage = async ({
[
threadId,
streamId,
- usage.totalInputTokens,
- usage.totalOutputTokens,
- usage.totalInputCredits,
- usage.totalOutputCredits,
- usage.totalCacheReadTokens,
- usage.totalCacheCreationTokens,
usage.contextWindowTokens,
usage.conversationSize,
usage.pendingQuestionMessageId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/ai-history.module.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/ai-history.module.ts
index ccbaced6f45..7b6aaf3f2ee 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/ai-history.module.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/ai-history.module.ts
@@ -4,6 +4,7 @@ import { FileUrlModule } from 'src/engine/core-modules/file/file-url/file-url.mo
import { AgentConversationReaderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service';
import { AgentConversationWriterService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service';
import { AgentHistoryTransactionService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-transaction.service';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
import { AgentHistoryWorkspaceStorageService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-workspace-storage.service';
import { AgentHistoryRepository } from 'src/engine/metadata-modules/ai/ai-history/repositories/agent-history-repository';
import { getAgentHistoryRepositoryToken } from 'src/engine/metadata-modules/ai/ai-history/repositories/inject-agent-history-repository.decorator';
@@ -26,12 +27,14 @@ const REPOSITORY_PROVIDERS = AGENT_HISTORY_OBJECT_NAMES.map((objectName) => ({
AgentHistoryTransactionService,
AgentConversationReaderService,
AgentConversationWriterService,
+ AgentTurnRecorderService,
...REPOSITORY_PROVIDERS,
],
exports: [
AgentHistoryWorkspaceStorageService,
AgentConversationReaderService,
AgentConversationWriterService,
+ AgentTurnRecorderService,
...REPOSITORY_PROVIDERS,
],
})
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/constants/agent-turn-credits-exhausted-error.constant.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/constants/agent-turn-credits-exhausted-error.constant.ts
new file mode 100644
index 00000000000..9e869839440
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/constants/agent-turn-credits-exhausted-error.constant.ts
@@ -0,0 +1,6 @@
+import { type StreamErrorPayload } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
+
+export const AGENT_TURN_CREDITS_EXHAUSTED_ERROR: StreamErrorPayload = {
+ code: 'CREDITS_EXHAUSTED',
+ message: 'The workspace ran out of credits.',
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum.ts
new file mode 100644
index 00000000000..b68044fd706
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum.ts
@@ -0,0 +1,7 @@
+export enum AgentTurnStatus {
+ RUNNING = 'running',
+ WAITING_FOR_INPUT = 'waiting_for_input',
+ COMPLETED = 'completed',
+ CANCELLED = 'cancelled',
+ FAILED = 'failed',
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/__tests__/agent-conversation-reader.service.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/__tests__/agent-conversation-reader.service.spec.ts
index 72dd16b5243..071392f839e 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/__tests__/agent-conversation-reader.service.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/__tests__/agent-conversation-reader.service.spec.ts
@@ -46,8 +46,13 @@ const buildTurn = ({
},
];
-const buildService = (messages: unknown[]) => {
+const buildService = (messages: unknown[], failedTurnIds: string[] = []) => {
const messageRepository = { find: jest.fn().mockResolvedValue(messages) };
+ const turnRepository = {
+ find: jest
+ .fn()
+ .mockResolvedValue(failedTurnIds.map((turnId) => ({ id: turnId }))),
+ };
const fileUrlService = {
signFileByIdUrl: jest
.fn()
@@ -56,6 +61,7 @@ const buildService = (messages: unknown[]) => {
const service = new AgentConversationReaderService(
messageRepository as never,
+ turnRepository as never,
fileUrlService as never,
);
@@ -89,6 +95,38 @@ const getPartTypes = (message: { parts: { type: string }[] }) =>
message.parts.map((part) => part.type);
describe('AgentConversationReaderService', () => {
+ it('leaves a failed run out of the conversation the agent continues from', async () => {
+ const { service } = buildService(
+ [
+ ...buildTurn({
+ turnId: 'turn-1',
+ senderUserWorkspaceId: MEMBER_A,
+ question: 'Who is our biggest customer?',
+ answer: 'Private Co',
+ }),
+ {
+ id: 'turn-2-user',
+ turnId: 'turn-2',
+ role: 'user',
+ senderUserWorkspaceId: MEMBER_A,
+ senderApplicationId: APPLICATION_ID,
+ parts: [{ type: 'text', textContent: 'And the second one?' }],
+ },
+ ],
+ ['turn-2'],
+ );
+
+ const messages = await service.loadMessages({
+ workspaceId: WORKSPACE_ID,
+ threadId: THREAD_ID,
+ });
+
+ expect(messages.map(({ id }) => id)).toEqual([
+ 'turn-1-user',
+ 'turn-1-assistant',
+ ]);
+ });
+
it('keeps every part when no actor is given', async () => {
const { service } = buildService([
...buildTurn({
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/__tests__/agent-turn-recorder.service.finish-executed-turn.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/__tests__/agent-turn-recorder.service.finish-executed-turn.spec.ts
new file mode 100644
index 00000000000..50734cc6c8c
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/__tests__/agent-turn-recorder.service.finish-executed-turn.spec.ts
@@ -0,0 +1,96 @@
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
+
+const TURN_USAGE = {
+ inputTokens: 10,
+ outputTokens: 5,
+ cacheReadTokens: 0,
+ cacheCreationTokens: 0,
+ inputCredits: 100,
+ outputCredits: 50,
+};
+
+const buildService = () => {
+ const service = new AgentTurnRecorderService({} as never);
+ const recordUsage = jest
+ .spyOn(service, 'recordUsage')
+ .mockResolvedValue(undefined);
+ const finish = jest.spyOn(service, 'finish').mockResolvedValue(true);
+
+ return { service, recordUsage, finish };
+};
+
+const turn = {
+ workspaceId: 'workspace-id',
+ threadId: 'thread-id',
+ turnId: 'turn-id',
+};
+
+describe('AgentTurnRecorderService.finishExecutedTurn', () => {
+ it('records the usage and completes the turn', async () => {
+ const { service, recordUsage, finish } = buildService();
+
+ await service.finishExecutedTurn({
+ ...turn,
+ execution: { modelId: 'model-id', turnUsage: TURN_USAGE },
+ });
+
+ expect(recordUsage).toHaveBeenCalledWith({ ...turn, usage: TURN_USAGE });
+ expect(finish).toHaveBeenCalledWith({
+ workspaceId: 'workspace-id',
+ turnId: 'turn-id',
+ modelId: 'model-id',
+ status: AgentTurnStatus.COMPLETED,
+ });
+ });
+
+ it('leaves a turn that asked a question waiting', async () => {
+ const { service, finish } = buildService();
+
+ await service.finishExecutedTurn({
+ ...turn,
+ execution: { turnUsage: TURN_USAGE },
+ isAwaitingAnswer: true,
+ });
+
+ expect(finish).toHaveBeenCalledWith(
+ expect.objectContaining({ status: AgentTurnStatus.WAITING_FOR_INPUT }),
+ );
+ });
+
+ it('fails a turn that ran out of credits', async () => {
+ const { service, finish } = buildService();
+
+ await service.finishExecutedTurn({
+ ...turn,
+ execution: { turnUsage: TURN_USAGE, hasNoMoreAvailableCredits: true },
+ isAwaitingAnswer: true,
+ });
+
+ expect(finish).toHaveBeenCalledWith(
+ expect.objectContaining({
+ status: AgentTurnStatus.FAILED,
+ error: expect.objectContaining({ code: 'CREDITS_EXHAUSTED' }),
+ }),
+ );
+ });
+
+ it('still ends the turn when its usage cannot be written', async () => {
+ const { service, recordUsage, finish } = buildService();
+
+ recordUsage.mockRejectedValue(new Error('database down'));
+
+ await service.finishExecutedTurn({
+ ...turn,
+ execution: { turnUsage: TURN_USAGE },
+ error: { code: 'EXECUTION_FAILED', message: 'Reply not saved.' },
+ });
+
+ expect(finish).toHaveBeenCalledWith(
+ expect.objectContaining({
+ status: AgentTurnStatus.FAILED,
+ error: { code: 'EXECUTION_FAILED', message: 'Reply not saved.' },
+ }),
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.ts
index 46cc2c8cf2b..f2d888ea82c 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service.ts
@@ -13,7 +13,9 @@ import { finalizeDanglingToolParts } from 'src/engine/metadata-modules/ai/ai-age
import { mapDBPartsToUIMessageParts } from 'src/engine/metadata-modules/ai/ai-agent-execution/utils/map-db-parts-to-ui-message-parts.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 { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
import { type AgentMessageWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message.workspace-entity';
+import { type AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity';
import { type AgentConversationActor } from 'src/engine/metadata-modules/ai/ai-history/types/agent-conversation-actor.type';
import { findTurnIdsActedByOthers } from 'src/engine/metadata-modules/ai/ai-history/utils/find-turn-ids-acted-by-others.util';
@@ -22,6 +24,8 @@ export class AgentConversationReaderService {
constructor(
@InjectAgentHistoryRepository('agentMessage')
private readonly messageRepository: AgentHistoryRepository<AgentMessageWorkspaceEntity>,
+ @InjectAgentHistoryRepository('agentTurn')
+ private readonly turnRepository: AgentHistoryRepository<AgentTurnWorkspaceEntity>,
private readonly fileUrlService: FileUrlService,
) {}
@@ -34,14 +38,26 @@ export class AgentConversationReaderService {
threadId: string;
actor?: AgentConversationActor;
}): Promise<ExtendedUIMessage[]> {
- const messages = await this.messageRepository.find(workspaceId, {
- where: { threadId },
- order: {
- processedAt: { order: 'ASC', nulls: 'NULLS LAST' },
- createdAt: 'ASC',
- },
- relations: ['parts', 'parts.file'],
- });
+ const [threadMessages, failedTurns] = await Promise.all([
+ this.messageRepository.find(workspaceId, {
+ where: { threadId },
+ order: {
+ processedAt: { order: 'ASC', nulls: 'NULLS LAST' },
+ createdAt: 'ASC',
+ },
+ relations: ['parts', 'parts.file'],
+ }),
+ this.turnRepository.find(workspaceId, {
+ where: { threadId, status: AgentTurnStatus.FAILED },
+ select: ['id'],
+ }),
+ ]);
+
+ // a failed run is kept on record but leaves the conversation as it was
+ const failedTurnIds = new Set(failedTurns.map(({ id }) => id));
+ const messages = threadMessages.filter(
+ ({ turnId }) => !isDefined(turnId) || !failedTurnIds.has(turnId),
+ );
const turnIdsActedByOthers = isDefined(actor)
? findTurnIdsActedByOthers({ messages, actor })
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service.ts
index 905bc435cfa..05742c82988 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-conversation-writer.service.ts
@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
import { randomUUID } from 'node:crypto';
import { type ExtendedUIMessagePart } from 'twenty-shared/ai';
+import { type ActorMetadata } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { IsNull } from 'typeorm';
@@ -12,12 +13,14 @@ import { mapUIMessagePartsToDBParts } from 'src/engine/metadata-modules/ai/ai-ag
import { type ToolCallWorkflowStep } from 'src/engine/metadata-modules/ai/ai-chat/types/tool-call-workflow-step.type';
import { stampPendingToolPartsWithWorkflowStep } from 'src/engine/metadata-modules/ai/ai-chat/utils/stamp-pending-tool-parts-with-workflow-step.util';
import { AgentMessageRole } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-role.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 { AgentHistoryTransactionService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-transaction.service';
import { type AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity';
import { type AgentHistoryTransactionScope } from 'src/engine/metadata-modules/ai/ai-history/types/agent-history-transaction-scope.type';
import { type RecordableAgentExecution } from 'src/engine/metadata-modules/ai/ai-history/types/recordable-agent-execution.type';
+import { isAgentTurnStatusFinal } from 'src/engine/metadata-modules/ai/ai-history/utils/is-agent-turn-status-final.util';
import {
AiException,
AiExceptionCode,
@@ -42,27 +45,40 @@ export class AgentConversationWriterService {
workspaceId,
threadId,
agentId,
+ status,
+ createdBy,
id,
scope,
}: {
workspaceId: string;
threadId: string;
agentId: string | null;
+ status: AgentTurnStatus;
+ createdBy?: ActorMetadata;
id?: string;
scope?: AgentHistoryTransactionScope;
}): Promise<string> {
+ const now = new Date().toISOString();
+ const values = {
+ threadId,
+ agentId,
+ status,
+ startedAt: now,
+ endedAt: isAgentTurnStatusFinal(status) ? now : null,
+ ...(isDefined(createdBy) ? { createdBy } : {}),
+ };
+
if (isDefined(scope)) {
const turnId = id ?? randomUUID();
- await scope.insert('agentTurn', { id: turnId, threadId, agentId });
+ await scope.insert('agentTurn', { id: turnId, ...values });
return turnId;
}
const turnInsertResult = await this.turnRepository.insert(workspaceId, {
...(isDefined(id) ? { id } : {}),
- threadId,
- agentId,
+ ...values,
});
return (id ?? turnInsertResult.identifiers[0].id) as string;
@@ -89,6 +105,7 @@ export class AgentConversationWriterService {
threadId,
id: turnId,
agentId: null,
+ status: AgentTurnStatus.RUNNING,
scope,
});
@@ -175,6 +192,12 @@ export class AgentConversationWriterService {
AiExceptionCode.THREAD_AWAITING_ANSWER,
);
}
+
+ await transactionScope.update(
+ 'agentTurn',
+ { id: turnId },
+ { status: AgentTurnStatus.WAITING_FOR_INPUT, endedAt: null },
+ );
};
if (isDefined(scope)) {
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service.ts
new file mode 100644
index 00000000000..ce4fdaa71e1
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service.ts
@@ -0,0 +1,324 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { type ActorMetadata, FieldActorSource } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type StreamErrorPayload } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
+import { AGENT_TURN_CREDITS_EXHAUSTED_ERROR } from 'src/engine/metadata-modules/ai/ai-history/constants/agent-turn-credits-exhausted-error.constant';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { type AgentHistoryStorageContext } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-workspace-storage.service';
+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 AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity';
+import { type AgentTurnUsage } from 'src/engine/metadata-modules/ai/ai-history/types/agent-turn-usage.type';
+import { type RecordableAgentExecution } from 'src/engine/metadata-modules/ai/ai-history/types/recordable-agent-execution.type';
+import { buildEndWaitingAgentTurnQuery } from 'src/engine/metadata-modules/ai/ai-history/utils/build-end-waiting-agent-turn-query.util';
+import { buildReleaseStreamClaimQuery } from 'src/engine/metadata-modules/ai/ai-history/utils/build-release-stream-claim-query.util';
+import { isAgentTurnStatusFinal } from 'src/engine/metadata-modules/ai/ai-history/utils/is-agent-turn-status-final.util';
+
+export type AgentTurnStreamClaim = {
+ threadId: string;
+ streamId: string;
+};
+
+const buildStreamClaimCondition = ({
+ table,
+ streamClaim,
+ firstParameterIndex,
+}: {
+ table: AgentHistoryStorageContext['table'];
+ streamClaim?: AgentTurnStreamClaim;
+ firstParameterIndex: number;
+}) =>
+ isDefined(streamClaim)
+ ? ` AND EXISTS (SELECT 1 FROM ${table('agentChatThread')} WHERE id = $${firstParameterIndex} AND "activeStreamId" = $${firstParameterIndex + 1})`
+ : '';
+
+const buildStreamClaimParameters = (streamClaim?: AgentTurnStreamClaim) =>
+ isDefined(streamClaim) ? [streamClaim.threadId, streamClaim.streamId] : [];
+
+@Injectable()
+export class AgentTurnRecorderService {
+ private readonly logger = new Logger(AgentTurnRecorderService.name);
+
+ constructor(
+ @InjectAgentHistoryRepository('agentTurn')
+ private readonly turnRepository: AgentHistoryRepository<AgentTurnWorkspaceEntity>,
+ ) {}
+
+ // A resumed or retried turn runs again, so it keeps its first start. Its
+ // creator is whoever first ran it: chat turns are inserted before their
+ // sender is known, so they carry the default creator until then
+ async markRunning({
+ workspaceId,
+ turnId,
+ modelId,
+ createdBy,
+ streamClaim,
+ }: {
+ workspaceId: string;
+ turnId: string;
+ modelId?: string;
+ createdBy?: ActorMetadata;
+ streamClaim?: AgentTurnStreamClaim;
+ }): Promise<boolean> {
+ return this.turnRepository.query(
+ workspaceId,
+ async ({ manager, table }) => {
+ const isDefaultCreator = `"createdBySource" = '${FieldActorSource.SYSTEM}' AND $3::boolean`;
+
+ const runningTurns = await manager.query<{ id: string }[]>(
+ `UPDATE ${table('agentTurn')} SET
+ "status" = '${AgentTurnStatus.RUNNING}',
+ "startedAt" = COALESCE("startedAt", now()),
+ "endedAt" = NULL,
+ "error" = NULL,
+ "modelId" = COALESCE($2, "modelId"),
+ "createdByWorkspaceMemberId" = CASE WHEN ${isDefaultCreator} THEN $5::uuid ELSE "createdByWorkspaceMemberId" END,
+ "createdByName" = CASE WHEN ${isDefaultCreator} THEN $6 ELSE "createdByName" END,
+ "createdByContext" = CASE WHEN ${isDefaultCreator} THEN $7::jsonb ELSE "createdByContext" END,
+ "createdBySource" = CASE WHEN ${isDefaultCreator} THEN $4 ELSE "createdBySource" END,
+ "updatedAt" = now()
+ WHERE id = $1${buildStreamClaimCondition({ table, streamClaim, firstParameterIndex: 8 })}
+ RETURNING id`,
+ [
+ turnId,
+ modelId ?? null,
+ isDefined(createdBy),
+ createdBy?.source ?? FieldActorSource.SYSTEM,
+ createdBy?.workspaceMemberId ?? null,
+ createdBy?.name ?? null,
+ JSON.stringify(createdBy?.context ?? {}),
+ ...buildStreamClaimParameters(streamClaim),
+ ],
+ );
+
+ return runningTurns.length > 0;
+ },
+ );
+ }
+
+ // A stream that lost its claim leaves the turn to whoever took the claim
+ async finish({
+ workspaceId,
+ turnId,
+ status,
+ error = null,
+ modelId,
+ streamClaim,
+ }: {
+ workspaceId: string;
+ turnId: string;
+ status: AgentTurnStatus;
+ error?: StreamErrorPayload | null;
+ modelId?: string;
+ streamClaim?: AgentTurnStreamClaim;
+ }): Promise<boolean> {
+ return this.turnRepository.query(
+ workspaceId,
+ async ({ manager, table }) => {
+ const finishedTurns = await manager.query<{ id: string }[]>(
+ `UPDATE ${table('agentTurn')} SET
+ "status" = $2,
+ "error" = $3::jsonb,
+ "endedAt" = $4,
+ "modelId" = COALESCE($5, "modelId"),
+ "updatedAt" = now()
+ WHERE id = $1${buildStreamClaimCondition({ table, streamClaim, firstParameterIndex: 6 })}
+ RETURNING id`,
+ [
+ turnId,
+ status,
+ isDefined(error) ? JSON.stringify(error) : null,
+ isAgentTurnStatusFinal(status) ? new Date().toISOString() : null,
+ modelId ?? null,
+ ...buildStreamClaimParameters(streamClaim),
+ ],
+ );
+
+ return finishedTurns.length > 0;
+ },
+ );
+ }
+
+ // Ends a turn run outside chat. Its credits were spent even when its reply
+ // could not be saved, and a failed usage write must not leave it running
+ async finishExecutedTurn({
+ workspaceId,
+ threadId,
+ turnId,
+ execution,
+ isAwaitingAnswer = false,
+ error,
+ }: {
+ workspaceId: string;
+ threadId: string;
+ turnId: string;
+ execution: RecordableAgentExecution;
+ isAwaitingAnswer?: boolean;
+ error?: StreamErrorPayload;
+ }): Promise<void> {
+ if (isDefined(execution.turnUsage)) {
+ await this.recordUsage({
+ workspaceId,
+ threadId,
+ turnId,
+ usage: execution.turnUsage,
+ }).catch((usageError: unknown) => {
+ this.logger.error(
+ `Failed to record the usage of agent turn ${turnId}: ${usageError instanceof Error ? usageError.message : String(usageError)}`,
+ );
+ });
+ }
+
+ const failureError =
+ error ??
+ (execution.hasNoMoreAvailableCredits === true
+ ? AGENT_TURN_CREDITS_EXHAUSTED_ERROR
+ : undefined);
+
+ await this.finish({
+ workspaceId,
+ turnId,
+ modelId: execution.modelId,
+ ...(isDefined(failureError)
+ ? { status: AgentTurnStatus.FAILED, error: failureError }
+ : {
+ status: isAwaitingAnswer
+ ? AgentTurnStatus.WAITING_FOR_INPUT
+ : AgentTurnStatus.COMPLETED,
+ }),
+ });
+ }
+
+ // Credits were spent whatever became of the turn, so usage is never guarded by a stream claim
+ async recordUsage({
+ workspaceId,
+ turnId,
+ threadId,
+ usage,
+ }: {
+ workspaceId: string;
+ turnId: string;
+ threadId: string;
+ usage: AgentTurnUsage;
+ }): Promise<void> {
+ await this.turnRepository.query(workspaceId, async ({ manager, table }) => {
+ // sum in Postgres: JS numbers must never be added to exact NUMERIC totals
+ await manager.query(
+ `WITH turn AS (
+ UPDATE ${table('agentTurn')} SET
+ "inputTokens" = COALESCE("inputTokens", 0) + $3,
+ "outputTokens" = COALESCE("outputTokens", 0) + $4,
+ "cacheReadTokens" = COALESCE("cacheReadTokens", 0) + $5,
+ "cacheCreationTokens" = COALESCE("cacheCreationTokens", 0) + $6,
+ "inputCredits" = COALESCE("inputCredits", 0) + $7,
+ "outputCredits" = COALESCE("outputCredits", 0) + $8,
+ "updatedAt" = now()
+ WHERE id = $1
+ RETURNING id
+ )
+ UPDATE ${table('agentChatThread')} SET
+ "totalInputTokens" = "totalInputTokens" + $3,
+ "totalOutputTokens" = "totalOutputTokens" + $4,
+ "totalCacheReadTokens" = "totalCacheReadTokens" + $5,
+ "totalCacheCreationTokens" = "totalCacheCreationTokens" + $6,
+ "totalInputCredits" = "totalInputCredits" + $7,
+ "totalOutputCredits" = "totalOutputCredits" + $8
+ WHERE id = $2`,
+ [
+ turnId,
+ threadId,
+ usage.inputTokens,
+ usage.outputTokens,
+ usage.cacheReadTokens,
+ usage.cacheCreationTokens,
+ usage.inputCredits,
+ usage.outputCredits,
+ ],
+ );
+ });
+ }
+
+ // the waiting turn is the one holding the question, whoever ends the wait
+ async endWaitingTurn({
+ workspaceId,
+ messageId,
+ status,
+ }: {
+ workspaceId: string;
+ messageId: string;
+ status: AgentTurnStatus.COMPLETED | AgentTurnStatus.CANCELLED;
+ }): Promise<void> {
+ await this.turnRepository.query(workspaceId, async ({ manager, table }) => {
+ await manager.query(buildEndWaitingAgentTurnQuery({ table }), [
+ messageId,
+ status,
+ ]);
+ });
+ }
+
+ // a thread runs one turn at a time, so the running turn is the one the released stream was running
+ async releaseStreamClaim({
+ workspaceId,
+ threadId,
+ streamId,
+ endRunningTurn,
+ }: AgentTurnStreamClaim & {
+ workspaceId: string;
+ endRunningTurn?: {
+ status: AgentTurnStatus.CANCELLED | AgentTurnStatus.FAILED;
+ error?: StreamErrorPayload | null;
+ };
+ }): Promise<boolean> {
+ return this.turnRepository.query(
+ workspaceId,
+ async ({ manager, table }) => {
+ const releasedThreads = await manager.query<{ id: string }[]>(
+ buildReleaseStreamClaimQuery({ table }),
+ [
+ threadId,
+ streamId,
+ endRunningTurn?.status ?? null,
+ isDefined(endRunningTurn?.error)
+ ? JSON.stringify(endRunningTurn.error)
+ : null,
+ ],
+ );
+
+ return releasedThreads.length > 0;
+ },
+ );
+ }
+
+ async findLatestTurn({
+ workspaceId,
+ threadId,
+ }: {
+ workspaceId: string;
+ threadId: string;
+ }): Promise<Pick<
+ AgentTurnWorkspaceEntity,
+ 'id' | 'status' | 'error'
+ > | null> {
+ return this.turnRepository.findOne(workspaceId, {
+ where: { threadId },
+ order: { createdAt: 'DESC', id: 'DESC' },
+ select: ['id', 'status', 'error'],
+ });
+ }
+
+ async findLatestTurnError({
+ workspaceId,
+ threadId,
+ }: {
+ workspaceId: string;
+ threadId: string;
+ }): Promise<StreamErrorPayload | null> {
+ const latestTurn = await this.findLatestTurn({ workspaceId, threadId });
+
+ return latestTurn?.status === AgentTurnStatus.FAILED
+ ? (latestTurn.error ?? null)
+ : null;
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity.ts
index 486ae79d6fc..99005ebffd8 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity.ts
@@ -5,7 +5,6 @@ import { type AgentTurnWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai
import { type AgentChatThreadParticipantWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread-participant.workspace-entity';
import { type AgentChatThreadTargetWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread-target.workspace-entity';
import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
-import { type AgentChatThreadLastStreamError } from 'src/engine/metadata-modules/ai/ai-chat/types/agent-chat-thread-last-stream-error.type';
import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
export class AgentChatThreadWorkspaceEntity extends BaseWorkspaceEntity {
@@ -35,5 +34,4 @@ export class AgentChatThreadWorkspaceEntity extends BaseWorkspaceEntity {
totalCacheCreationTokens: string;
activeStreamId: string | null;
pendingQuestionMessageId: string | null;
- lastStreamError: AgentChatThreadLastStreamError | null;
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity.ts
index b1f67bc7934..10d215fdb31 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/standard-objects/agent-turn.workspace-entity.ts
@@ -1,6 +1,10 @@
+import { type ActorMetadata } from 'twenty-shared/types';
+
import { type EntityRelation } from 'src/engine/workspace-manager/workspace-migration/types/entity-relation.interface';
import { type AgentChatThreadWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-chat-thread.workspace-entity';
import { type AgentMessageWorkspaceEntity } from 'src/engine/metadata-modules/ai/ai-history/standard-objects/agent-message.workspace-entity';
+import { type AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { type StreamErrorPayload } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
export class AgentTurnWorkspaceEntity extends BaseWorkspaceEntity {
@@ -9,4 +13,16 @@ export class AgentTurnWorkspaceEntity extends BaseWorkspaceEntity {
threadId: string;
agentId: string | null;
+ status: AgentTurnStatus;
+ error: StreamErrorPayload | null;
+ startedAt: string | null;
+ endedAt: string | null;
+ modelId: string | null;
+ inputTokens: number | null;
+ outputTokens: number | null;
+ cacheReadTokens: string | null;
+ cacheCreationTokens: string | null;
+ inputCredits: string | null;
+ outputCredits: string | null;
+ createdBy: ActorMetadata;
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/types/agent-turn-usage.type.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/types/agent-turn-usage.type.ts
new file mode 100644
index 00000000000..8c39fee5558
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/types/agent-turn-usage.type.ts
@@ -0,0 +1,9 @@
+// credits are in micro credits, like the thread totals they add up to
+export type AgentTurnUsage = {
+ inputTokens: number;
+ outputTokens: number;
+ cacheReadTokens: number;
+ cacheCreationTokens: number;
+ inputCredits: number;
+ outputCredits: number;
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/types/recordable-agent-execution.type.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/types/recordable-agent-execution.type.ts
index 10a61a1ce78..8ac5a61b582 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/types/recordable-agent-execution.type.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/types/recordable-agent-execution.type.ts
@@ -1,6 +1,12 @@
import { type AgentExecutionResult } from 'src/engine/metadata-modules/ai/ai-agent-execution/types/agent-execution-result.type';
+// what recording a turn reads from an execution; usage is absent when the execution ran elsewhere
export type RecordableAgentExecution = {
steps?: Pick<AgentExecutionResult['steps'][number], 'content'>[];
isPaused?: boolean;
-};
+} & Partial<
+ Pick<
+ AgentExecutionResult,
+ 'modelId' | 'turnUsage' | 'hasNoMoreAvailableCredits'
+ >
+>;
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/build-end-waiting-agent-turn-query.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/build-end-waiting-agent-turn-query.util.ts
new file mode 100644
index 00000000000..0fda7336c12
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/build-end-waiting-agent-turn-query.util.ts
@@ -0,0 +1,12 @@
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { type AgentHistoryObjectName } from 'src/engine/metadata-modules/ai/ai-history/types/agent-history-object-name.type';
+
+// $1 is the question message id and $2 the status the turn ends with
+export const buildEndWaitingAgentTurnQuery = ({
+ table,
+}: {
+ table: (name: AgentHistoryObjectName) => string;
+}): string =>
+ `UPDATE ${table('agentTurn')} turn SET "status" = $2, "endedAt" = now(), "updatedAt" = now()
+ FROM ${table('agentMessage')} message
+ WHERE message.id = $1 AND turn.id = message."turnId" AND turn."status" = '${AgentTurnStatus.WAITING_FOR_INPUT}'`;
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/build-release-stream-claim-query.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/build-release-stream-claim-query.util.ts
new file mode 100644
index 00000000000..c5c67be1f52
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/build-release-stream-claim-query.util.ts
@@ -0,0 +1,20 @@
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { type AgentHistoryObjectName } from 'src/engine/metadata-modules/ai/ai-history/types/agent-history-object-name.type';
+
+// One statement, so a request that claims the thread right after cannot have
+// its new turn ended. Parameters: thread id, stream id, then the status and
+// error to end the running turn with, or null to leave it as is
+export const buildReleaseStreamClaimQuery = ({
+ table,
+}: {
+ table: (name: AgentHistoryObjectName) => string;
+}): string =>
+ `WITH released AS (
+ UPDATE ${table('agentChatThread')} SET "activeStreamId" = NULL, "updatedAt" = now()
+ WHERE id = $1 AND "activeStreamId" = $2
+ RETURNING id
+ ), ended AS (
+ UPDATE ${table('agentTurn')} SET "status" = $3, "error" = $4::jsonb, "endedAt" = now(), "updatedAt" = now()
+ WHERE $3::text IS NOT NULL AND "threadId" IN (SELECT id FROM released) AND "status" = '${AgentTurnStatus.RUNNING}'
+ RETURNING id
+ ) SELECT id FROM released`;
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/is-agent-turn-status-final.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/is-agent-turn-status-final.util.ts
new file mode 100644
index 00000000000..46625c10987
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-history/utils/is-agent-turn-status-final.util.ts
@@ -0,0 +1,6 @@
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+
+export const isAgentTurnStatusFinal = (status: AgentTurnStatus): boolean =>
+ status === AgentTurnStatus.COMPLETED ||
+ status === AgentTurnStatus.CANCELLED ||
+ status === AgentTurnStatus.FAILED;
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 d1bb82b797e..9e835932fb0 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
@@ -36,6 +36,7 @@ import { WorkflowRunStatus } from 'src/modules/workflow/common/standard-objects/
import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
import { WorkflowRunWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service';
import { WorkflowRunnerWorkspaceService } from 'src/modules/workflow/workflow-runner/workspace-services/workflow-runner.workspace-service';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
type AnswerToolCallArgs = {
threadId: string;
@@ -284,6 +285,10 @@ export class ToolCallAnswerService {
const answerMessage = await this.agentChatService.addMessage({
threadId,
userWorkspaceId,
+ turnStatus:
+ isDefined(step) || !isLastAnswer
+ ? AgentTurnStatus.COMPLETED
+ : AgentTurnStatus.RUNNING,
uiMessage: {
role: AgentMessageRole.USER,
parts: [{ type: 'text', text: answerText }],
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts
index ebbdec0c89d..2ed2f114095 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts
@@ -33,6 +33,7 @@ import { proposeRecordCall } from 'src/engine/workspace-manager/dev-seeder/data/
import { requestFormCall } from 'src/engine/workspace-manager/dev-seeder/data/utils/request-form-call.util';
import { type SeededEmail } from 'src/engine/workspace-manager/dev-seeder/data/utils/seeded-email.type';
import { type SeededToolCall } from 'src/engine/workspace-manager/dev-seeder/data/utils/seeded-tool-call.type';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
const AGENT_CHAT_PENDING_INPUT_SEED_NAMESPACE =
'3c7e1f52-8a4d-4b0e-9d61-2f5a7c9e0b14';
@@ -422,6 +423,9 @@ export class DevSeederAgentChatPendingInputWorkspaceService {
id: questionTurnId,
threadId,
agentId: null,
+ status: isDefined(conversation.answer)
+ ? AgentTurnStatus.COMPLETED
+ : AgentTurnStatus.WAITING_FOR_INPUT,
});
await this.conversationWriterService.insertMessage({
@@ -494,6 +498,7 @@ export class DevSeederAgentChatPendingInputWorkspaceService {
id: answerTurnId,
threadId,
agentId: null,
+ status: AgentTurnStatus.COMPLETED,
});
await this.conversationWriterService.insertMessage({
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-workflow-pending-input.workspace-service.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-workflow-pending-input.workspace-service.ts
index c046139bbfd..04ba7d58148 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-workflow-pending-input.workspace-service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-workflow-pending-input.workspace-service.ts
@@ -267,14 +267,21 @@ export class DevSeederWorkflowPendingInputWorkspaceService {
throw error;
});
- await this.workflowAgentConversationService.recordExecution({
+ const turnId = await this.workflowAgentConversationService.openTurn({
+ runInfo: { workspaceId, workflowRunId },
+ threadId,
+ agentId: null,
+ prompt: agentWorkflow.runPrompt,
+ initiatorUserWorkspaceId: null,
+ });
+
+ await this.workflowAgentConversationService.closeTurn({
workspaceId,
threadId,
+ turnId,
workflowStep: { workflowRunId, stepId: workflow.step.id },
title: workflow.step.name,
agentId: null,
- prompt: agentWorkflow.runPrompt,
- initiatorUserWorkspaceId: null,
executionResult: {
isPaused: true,
steps: [{ content }],
diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/__snapshots__/get-standard-object-metadata-related-entity-ids.util.spec.ts.snap b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/__snapshots__/get-standard-object-metadata-related-entity-ids.util.spec.ts.snap
index 9587cc9b92f..a82aa67ac35 100644
--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/__snapshots__/get-standard-object-metadata-related-entity-ids.util.spec.ts.snap
+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/__snapshots__/get-standard-object-metadata-related-entity-ids.util.spec.ts.snap
@@ -158,139 +158,139 @@ exports[`getStandardObjectMetadataRelatedEntityIds should return standard object
"agentMessage": {
"fields": {
"agentId": {
- "id": "00000000-0000-0000-0000-000000001074",
+ "id": "00000000-0000-0000-0000-000000001086",
},
"createdAt": {
- "id": "00000000-0000-0000-0000-000000001071",
+ "id": "00000000-0000-0000-0000-000000001083",
},
"deletedAt": {
- "id": "00000000-0000-0000-0000-000000001073",
+ "id": "00000000-0000-0000-0000-000000001085",
},
"id": {
- "id": "00000000-0000-0000-0000-000000001070",
+ "id": "00000000-0000-0000-0000-000000001082",
},
"isHidden": {
- "id": "00000000-0000-0000-0000-000000001080",
+ "id": "00000000-0000-0000-0000-000000001092",
},
"parts": {
- "id": "00000000-0000-0000-0000-000000001084",
+ "id": "00000000-0000-0000-0000-000000001096",
},
"processedAt": {
- "id": "00000000-0000-0000-0000-000000001081",
+ "id": "00000000-0000-0000-0000-000000001093",
},
"role": {
- "id": "00000000-0000-0000-0000-000000001078",
+ "id": "00000000-0000-0000-0000-000000001090",
},
"senderApplicationId": {
- "id": "00000000-0000-0000-0000-000000001077",
+ "id": "00000000-0000-0000-0000-000000001089",
},
"senderUserWorkspaceId": {
- "id": "00000000-0000-0000-0000-000000001076",
+ "id": "00000000-0000-0000-0000-000000001088",
},
"senderWorkspaceMember": {
- "id": "00000000-0000-0000-0000-000000001075",
+ "id": "00000000-0000-0000-0000-000000001087",
},
"status": {
- "id": "00000000-0000-0000-0000-000000001079",
+ "id": "00000000-0000-0000-0000-000000001091",
},
"thread": {
- "id": "00000000-0000-0000-0000-000000001082",
+ "id": "00000000-0000-0000-0000-000000001094",
},
"turn": {
- "id": "00000000-0000-0000-0000-000000001083",
+ "id": "00000000-0000-0000-0000-000000001095",
},
"updatedAt": {
- "id": "00000000-0000-0000-0000-000000001072",
+ "id": "00000000-0000-0000-0000-000000001084",
},
},
- "id": "00000000-0000-0000-0000-000000001085",
+ "id": "00000000-0000-0000-0000-000000001097",
"views": undefined,
},
"agentMessagePart": {
"fields": {
"createdAt": {
- "id": "00000000-0000-0000-0000-000000001087",
+ "id": "00000000-0000-0000-0000-000000001099",
},
"deletedAt": {
- "id": "00000000-0000-0000-0000-000000001089",
+ "id": "00000000-0000-0000-0000-000000001101",
},
"errorDetails": {
- "id": "00000000-0000-0000-0000-000000001101",
+ "id": "00000000-0000-0000-0000-000000001113",
},
"errorMessage": {
- "id": "00000000-0000-0000-0000-000000001100",
+ "id": "00000000-0000-0000-0000-000000001112",
},
"fileFilename": {
- "id": "00000000-0000-0000-0000-000000001109",
+ "id": "00000000-0000-0000-0000-000000001121",
},
"fileId": {
- "id": "00000000-0000-0000-0000-000000001110",
+ "id": "00000000-0000-0000-0000-000000001122",
},
"id": {
- "id": "00000000-0000-0000-0000-000000001086",
+ "id": "00000000-0000-0000-0000-000000001098",
},
"message": {
- "id": "00000000-0000-0000-0000-000000001112",
+ "id": "00000000-0000-0000-0000-000000001124",
},
"orderIndex": {
- "id": "00000000-0000-0000-0000-000000001090",
+ "id": "00000000-0000-0000-0000-000000001102",
},
"providerExecuted": {
- "id": "00000000-0000-0000-0000-000000001099",
+ "id": "00000000-0000-0000-0000-000000001111",
},
"providerMetadata": {
- "id": "00000000-0000-0000-0000-000000001111",
+ "id": "00000000-0000-0000-0000-000000001123",
},
"reasoningContent": {
- "id": "00000000-0000-0000-0000-000000001093",
+ "id": "00000000-0000-0000-0000-000000001105",
},
"sourceDocumentFilename": {
- "id": "00000000-0000-0000-0000-000000001108",
+ "id": "00000000-0000-0000-0000-000000001120",
},
"sourceDocumentMediaType": {
- "id": "00000000-0000-0000-0000-000000001106",
+ "id": "00000000-0000-0000-0000-000000001118",
},
"sourceDocumentSourceId": {
- "id": "00000000-0000-0000-0000-000000001105",
+ "id": "00000000-0000-0000-0000-000000001117",
},
"sourceDocumentTitle": {
- "id": "00000000-0000-0000-0000-000000001107",
+ "id": "00000000-0000-0000-0000-000000001119",
},
"sourceUrlSourceId": {
- "id": "00000000-0000-0000-0000-000000001102",
+ "id": "00000000-0000-0000-0000-000000001114",
},
"sourceUrlTitle": {
- "id": "00000000-0000-0000-0000-000000001104",
+ "id": "00000000-0000-0000-0000-000000001116",
},
"sourceUrlUrl": {
- "id": "00000000-0000-0000-0000-000000001103",
+ "id": "00000000-0000-0000-0000-000000001115",
},
"state": {
- "id": "00000000-0000-0000-0000-000000001098",
+ "id": "00000000-0000-0000-0000-000000001110",
},
"textContent": {
- "id": "00000000-0000-0000-0000-000000001092",
+ "id": "00000000-0000-0000-0000-000000001104",
},
"toolCallId": {
- "id": "00000000-0000-0000-0000-000000001095",
+ "id": "00000000-0000-0000-0000-000000001107",
},
"toolInput": {
- "id": "00000000-0000-0000-0000-000000001096",
+ "id": "00000000-0000-0000-0000-000000001108",
},
"toolName": {
- "id": "00000000-0000-0000-0000-000000001094",
+ "id": "00000000-0000-0000-0000-000000001106",
},
"toolOutput": {
- "id": "00000000-0000-0000-0000-000000001097",
+ "id": "00000000-0000-0000-0000-000000001109",
},
"type": {
- "id": "00000000-0000-0000-0000-000000001091",
+ "id": "00000000-0000-0000-0000-000000001103",
},
"updatedAt": {
- "id": "00000000-0000-0000-0000-000000001088",
+ "id": "00000000-0000-0000-0000-000000001100",
},
},
- "id": "00000000-0000-0000-0000-000000001113",
+ "id": "00000000-0000-0000-0000-000000001125",
"views": undefined,
},
"agentTurn": {
@@ -298,18 +298,54 @@ exports[`getStandardObjectMetadataRelatedEntityIds should return standard object
"agentId": {
"id": "00000000-0000-0000-0000-000000001066",
},
+ "cacheCreationTokens": {
+ "id": "00000000-0000-0000-0000-000000001077",
+ },
+ "cacheReadTokens": {
+ "id": "00000000-0000-0000-0000-000000001076",
+ },
"createdAt": {
"id": "00000000-0000-0000-0000-000000001063",
},
+ "createdBy": {
+ "id": "00000000-0000-0000-0000-000000001080",
+ },
"deletedAt": {
"id": "00000000-0000-0000-0000-000000001065",
},
+ "endedAt": {
+ "id": "00000000-0000-0000-0000-000000001072",
+ },
+ "error": {
+ "id": "00000000-0000-0000-0000-000000001070",
+ },
"id": {
"id": "00000000-0000-0000-0000-000000001062",
},
+ "inputCredits": {
+ "id": "00000000-0000-0000-0000-000000001078",
+ },
+ "inputTokens": {
+ "id": "00000000-0000-0000-0000-000000001074",
+ },
"messages": {
"id": "00000000-0000-0000-0000-000000001068",
},
+ "modelId": {
+ "id": "00000000-0000-0000-0000-000000001073",
+ },
+ "outputCredits": {
+ "id": "00000000-0000-0000-0000-000000001079",
+ },
+ "outputTokens": {
+ "id": "00000000-0000-0000-0000-000000001075",
+ },
+ "startedAt": {
+ "id": "00000000-0000-0000-0000-000000001071",
+ },
+ "status": {
+ "id": "00000000-0000-0000-0000-000000001069",
+ },
"thread": {
"id": "00000000-0000-0000-0000-000000001067",
},
@@ -317,7 +353,7 @@ exports[`getStandardObjectMetadataRelatedEntityIds should return standard object
"id": "00000000-0000-0000-0000-000000001064",
},
},
- "id": "00000000-0000-0000-0000-000000001069",
+ "id": "00000000-0000-0000-0000-000000001081",
"views": undefined,
},
"attachment": {
@@ -1075,64 +1111,64 @@ exports[`getStandardObjectMetadataRelatedEntityIds should return standard object
"campaignDelivery": {
"fields": {
"bouncedAt": {
- "id": "00000000-0000-0000-0000-000000001129",
+ "id": "00000000-0000-0000-0000-000000001141",
},
"campaignId": {
- "id": "00000000-0000-0000-0000-000000001118",
+ "id": "00000000-0000-0000-0000-000000001130",
},
"claimExpiresAt": {
- "id": "00000000-0000-0000-0000-000000001125",
+ "id": "00000000-0000-0000-0000-000000001137",
},
"claimToken": {
- "id": "00000000-0000-0000-0000-000000001124",
+ "id": "00000000-0000-0000-0000-000000001136",
},
"complainedAt": {
- "id": "00000000-0000-0000-0000-000000001130",
+ "id": "00000000-0000-0000-0000-000000001142",
},
"createdAt": {
- "id": "00000000-0000-0000-0000-000000001115",
+ "id": "00000000-0000-0000-0000-000000001127",
},
"deletedAt": {
- "id": "00000000-0000-0000-0000-000000001117",
+ "id": "00000000-0000-0000-0000-000000001129",
},
"deliveredAt": {
- "id": "00000000-0000-0000-0000-000000001128",
+ "id": "00000000-0000-0000-0000-000000001140",
},
"failureReason": {
- "id": "00000000-0000-0000-0000-000000001123",
+ "id": "00000000-0000-0000-0000-000000001135",
},
"id": {
- "id": "00000000-0000-0000-0000-000000001114",
+ "id": "00000000-0000-0000-0000-000000001126",
},
"personId": {
- "id": "00000000-0000-0000-0000-000000001119",
+ "id": "00000000-0000-0000-0000-000000001131",
},
"providerMessageId": {
- "id": "00000000-0000-0000-0000-000000001126",
+ "id": "00000000-0000-0000-0000-000000001138",
},
"recipientEmail": {
- "id": "00000000-0000-0000-0000-000000001120",
+ "id": "00000000-0000-0000-0000-000000001132",
},
"rejectedAt": {
- "id": "00000000-0000-0000-0000-000000001131",
+ "id": "00000000-0000-0000-0000-000000001143",
},
"renderingFailedAt": {
- "id": "00000000-0000-0000-0000-000000001132",
+ "id": "00000000-0000-0000-0000-000000001144",
},
"sentAt": {
- "id": "00000000-0000-0000-0000-000000001127",
+ "id": "00000000-0000-0000-0000-000000001139",
},
"skipReason": {
- "id": "00000000-0000-0000-0000-000000001122",
+ "id": "00000000-0000-0000-0000-000000001134",
},
"state": {
- "id": "00000000-0000-0000-0000-000000001121",
+ "id": "00000000-0000-0000-0000-000000001133",
},
"updatedAt": {
- "id": "00000000-0000-0000-0000-000000001116",
+ "id": "00000000-0000-0000-0000-000000001128",
},
},
- "id": "00000000-0000-0000-0000-000000001133",
+ "id": "00000000-0000-0000-0000-000000001145",
"views": undefined,
},
"company": {
@@ -2089,34 +2125,34 @@ exports[`getStandardObjectMetadataRelatedEntityIds should return standard object
"messageSuppression": {
"fields": {
"createdAt": {
- "id": "00000000-0000-0000-0000-000000001135",
+ "id": "00000000-0000-0000-0000-000000001147",
},
"deletedAt": {
- "id": "00000000-0000-0000-0000-000000001137",
+ "id": "00000000-0000-0000-0000-000000001149",
},
"emailAddress": {
- "id": "00000000-0000-0000-0000-000000001138",
+ "id": "00000000-0000-0000-0000-000000001150",
},
"id": {
- "id": "00000000-0000-0000-0000-000000001134",
+ "id": "00000000-0000-0000-0000-000000001146",
},
"providerEventId": {
- "id": "00000000-0000-0000-0000-000000001141",
+ "id": "00000000-0000-0000-0000-000000001153",
},
"reason": {
- "id": "00000000-0000-0000-0000-000000001139",
+ "id": "00000000-0000-0000-0000-000000001151",
},
"source": {
- "id": "00000000-0000-0000-0000-000000001140",
+ "id": "00000000-0000-0000-0000-000000001152",
},
"unsubscribeTopicId": {
- "id": "00000000-0000-0000-0000-000000001142",
+ "id": "00000000-0000-0000-0000-000000001154",
},
"updatedAt": {
- "id": "00000000-0000-0000-0000-000000001136",
+ "id": "00000000-0000-0000-0000-000000001148",
},
},
- "id": "00000000-0000-0000-0000-000000001143",
+ "id": "00000000-0000-0000-0000-000000001155",
"views": undefined,
},
"messageThread": {
diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-chat-thread-standard-flat-field-metadata.util.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-chat-thread-standard-flat-field-metadata.util.ts
index ef49c383fcf..311d10b95f4 100644
--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-chat-thread-standard-flat-field-metadata.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-chat-thread-standard-flat-field-metadata.util.ts
@@ -363,6 +363,7 @@ export const buildAgentChatThreadStandardFlatFieldMetadatas = (
writability: MetadataWritability.SYSTEM,
isAuditLogged: false,
},
+ // Failed turns hold their error now; the 2.42 history move and the 2.46 backfill still read it
lastStreamError: {
...createStandardFieldFlatMetadata({
...args,
diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-turn-standard-flat-field-metadata.util.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-turn-standard-flat-field-metadata.util.ts
index 211398c8eb6..04366b0093d 100644
--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-turn-standard-flat-field-metadata.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-agent-turn-standard-flat-field-metadata.util.ts
@@ -1,11 +1,13 @@
import { type AllStandardObjectFieldName } from 'src/engine/workspace-manager/twenty-standard-application/types/all-standard-object-field-name.type';
import { msg } from '@lingui/core/macro';
import {
+ FieldActorSource,
FieldMetadataType,
MetadataWritability,
RelationType,
RelationOnDeleteAction,
} from 'twenty-shared/types';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import {
type CreateStandardFieldArgs,
@@ -63,6 +65,285 @@ export const buildAgentTurnStandardFlatFieldMetadatas = (
writability: MetadataWritability.SYSTEM,
isAuditLogged: false,
},
+ status: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'status',
+ type: FieldMetadataType.TEXT,
+ label: i18nLabel(
+ msg({ message: 'Status', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({ message: 'Status', context: 'fieldMetadata.description' }),
+ ),
+ icon: 'IconProgressCheck',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: false,
+ defaultValue: `'${AgentTurnStatus.COMPLETED}'`,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ error: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'error',
+ type: FieldMetadataType.RAW_JSON,
+ label: i18nLabel(
+ msg({ message: 'Error', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({ message: 'Error', context: 'fieldMetadata.description' }),
+ ),
+ icon: 'IconAlertTriangle',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ startedAt: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'startedAt',
+ type: FieldMetadataType.DATE_TIME,
+ label: i18nLabel(
+ msg({ message: 'Started At', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({ message: 'Started At', context: 'fieldMetadata.description' }),
+ ),
+ icon: 'IconCalendarClock',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ endedAt: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'endedAt',
+ type: FieldMetadataType.DATE_TIME,
+ label: i18nLabel(
+ msg({ message: 'Ended At', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({ message: 'Ended At', context: 'fieldMetadata.description' }),
+ ),
+ icon: 'IconCalendarClock',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ modelId: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'modelId',
+ type: FieldMetadataType.TEXT,
+ label: i18nLabel(
+ msg({ message: 'Model ID', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({ message: 'Model ID', context: 'fieldMetadata.description' }),
+ ),
+ icon: 'IconBrain',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ inputTokens: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'inputTokens',
+ type: FieldMetadataType.NUMBER,
+ label: i18nLabel(
+ msg({ message: 'Input Tokens', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({
+ message: 'Input Tokens',
+ context: 'fieldMetadata.description',
+ }),
+ ),
+ icon: 'IconNumber',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ outputTokens: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'outputTokens',
+ type: FieldMetadataType.NUMBER,
+ label: i18nLabel(
+ msg({ message: 'Output Tokens', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({
+ message: 'Output Tokens',
+ context: 'fieldMetadata.description',
+ }),
+ ),
+ icon: 'IconNumber',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ cacheReadTokens: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'cacheReadTokens',
+ type: FieldMetadataType.NUMERIC,
+ label: i18nLabel(
+ msg({ message: 'Cache Read Tokens', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({
+ message: 'Cache Read Tokens',
+ context: 'fieldMetadata.description',
+ }),
+ ),
+ icon: 'IconNumber',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ cacheCreationTokens: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'cacheCreationTokens',
+ type: FieldMetadataType.NUMERIC,
+ label: i18nLabel(
+ msg({
+ message: 'Cache Creation Tokens',
+ context: 'fieldMetadata.label',
+ }),
+ ),
+ description: i18nLabel(
+ msg({
+ message: 'Cache Creation Tokens',
+ context: 'fieldMetadata.description',
+ }),
+ ),
+ icon: 'IconNumber',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ inputCredits: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'inputCredits',
+ type: FieldMetadataType.NUMERIC,
+ label: i18nLabel(
+ msg({ message: 'Input Credits', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({
+ message: 'Input Credits',
+ context: 'fieldMetadata.description',
+ }),
+ ),
+ icon: 'IconCoin',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ outputCredits: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'outputCredits',
+ type: FieldMetadataType.NUMERIC,
+ label: i18nLabel(
+ msg({ message: 'Output Credits', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({
+ message: 'Output Credits',
+ context: 'fieldMetadata.description',
+ }),
+ ),
+ icon: 'IconCoin',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: true,
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
+ createdBy: {
+ ...createStandardFieldFlatMetadata({
+ ...args,
+ context: {
+ fieldName: 'createdBy',
+ type: FieldMetadataType.ACTOR,
+ label: i18nLabel(
+ msg({ message: 'Created by', context: 'fieldMetadata.label' }),
+ ),
+ description: i18nLabel(
+ msg({ message: 'Created by', context: 'fieldMetadata.description' }),
+ ),
+ icon: 'IconCreativeCommonsSa',
+ isSystem: true,
+ isUIEditable: false,
+ isNullable: false,
+ defaultValue: {
+ source: `'${FieldActorSource.SYSTEM}'`,
+ name: "'System'",
+ workspaceMemberId: null,
+ },
+ },
+ }),
+ writability: MetadataWritability.SYSTEM,
+ isAuditLogged: false,
+ },
createdAt: {
...createStandardFieldFlatMetadata({
...args,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/ai-agent.workflow-action.ts b/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/ai-agent.workflow-action.ts
index 9689cdb6283..60d905b11ae 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/ai-agent.workflow-action.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/ai-agent.workflow-action.ts
@@ -39,10 +39,7 @@ import { findAgentStepWait } from 'src/modules/workflow/workflow-executor/workfl
import { type WorkflowWaitResolution } from 'src/modules/workflow/workflow-wait/types/workflow-wait-resolution.type';
import { type WorkflowWaitResolutionInput } from 'src/modules/workflow/workflow-wait/types/workflow-wait-resolution-input.type';
import { WORKFLOW_AGENT_HUMAN_INPUT_PROMPT } from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/constants/workflow-agent-human-input-prompt.constant';
-import {
- type RecordedConversation,
- WorkflowAgentConversationWorkspaceService,
-} from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/workflow-agent-conversation.workspace-service';
+import { WorkflowAgentConversationWorkspaceService } from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/workflow-agent-conversation.workspace-service';
import { type WorkflowAiAgentActionInput } from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/types/workflow-ai-agent-action-input.type';
import { mergeAiAgentStepLogs } from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/utils/merge-ai-agent-step-logs.util';
import { buildAiAgentStepLog } from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/utils/build-ai-agent-step-log.util';
@@ -190,29 +187,12 @@ export class AiAgentWorkflowAction implements WorkflowAction {
};
// A record of the step, not its outcome, so a write failure must not fail the step
- const recordConversation = (
- executionResult: AgentExecutionResult,
- ): Promise<RecordedConversation | null> =>
- (conversationThread.isResumed
- ? this.workflowAgentConversationService.recordContinuation({
- workspaceId,
- threadId: conversationThread.threadId,
- workflowStep,
- title: step.name,
- agentId: agent?.id ?? null,
- executionResult,
- })
- : this.workflowAgentConversationService.recordExecution({
- workspaceId,
- threadId: conversationThread.threadId,
- workflowStep,
- title: step.name,
- agentId: agent?.id ?? null,
- prompt: resolvedPrompt,
- initiatorUserWorkspaceId: userWorkspaceId,
- executionResult,
- })
- ).catch((error: unknown) => {
+ const recordConversation = async <TResult>(
+ record: () => Promise<TResult>,
+ ): Promise<TResult | null> => {
+ try {
+ return await record();
+ } catch (error) {
this.logger.warn(
`Failed to record the conversation for workflowRun=${runInfo.workflowRunId} step=${currentStepId}: ${
error instanceof Error ? error.message : String(error)
@@ -220,54 +200,93 @@ export class AiAgentWorkflowAction implements WorkflowAction {
);
return null;
- });
+ }
+ };
+
+ const turnId = await recordConversation(() =>
+ this.workflowAgentConversationService.openTurn({
+ runInfo,
+ threadId: conversationThread.threadId,
+ agentId: agent?.id ?? null,
+ prompt: conversationThread.isResumed ? null : resolvedPrompt,
+ initiatorUserWorkspaceId: userWorkspaceId,
+ }),
+ );
const trimmedHumanInputInstructions = humanInputInstructions?.trim();
const canAskForHumanInput = isNonEmptyString(trimmedHumanInputInstructions);
const startedAtMs = Date.now();
- const executionResult = await this.aiAgentExecutionService.executeAgent({
- agent,
- messages: conversationThread.isResumed
- ? []
- : [{ role: 'user', content: resolvedPrompt }],
- priorMessages: conversationThread.priorMessages,
- baseSystemPrompt: canAskForHumanInput
- ? `${WORKFLOW_BASE_SYSTEM_PROMPT}\n\n${WORKFLOW_AGENT_WAIT_PROMPT}\n\n${WORKFLOW_AGENT_HUMAN_INPUT_PROMPT}\n\n${trimmedHumanInputInstructions}`
- : `${WORKFLOW_BASE_SYSTEM_PROMPT}\n\n${WORKFLOW_AGENT_WAIT_PROMPT}`,
- pausingTools: {
- ...createWorkflowAgentWaitTools(),
- ...(canAskForHumanInput
+ let executionResult: AgentExecutionResult;
+
+ try {
+ executionResult = await this.aiAgentExecutionService.executeAgent({
+ agent,
+ messages: conversationThread.isResumed
+ ? []
+ : [{ role: 'user', content: resolvedPrompt }],
+ priorMessages: conversationThread.priorMessages,
+ baseSystemPrompt: canAskForHumanInput
+ ? `${WORKFLOW_BASE_SYSTEM_PROMPT}\n\n${WORKFLOW_AGENT_WAIT_PROMPT}\n\n${WORKFLOW_AGENT_HUMAN_INPUT_PROMPT}\n\n${trimmedHumanInputInstructions}`
+ : `${WORKFLOW_BASE_SYSTEM_PROMPT}\n\n${WORKFLOW_AGENT_WAIT_PROMPT}`,
+ pausingTools: {
+ ...createWorkflowAgentWaitTools(),
+ ...(canAskForHumanInput
+ ? {
+ [ASK_QUESTION_TOOL_NAME]: createAskQuestionTool({
+ isWorkspaceSetupThread: false,
+ }),
+ [REQUEST_FORM_TOOL_NAME]: createRequestFormTool(),
+ }
+ : {}),
+ },
+ canProposeToolCalls: canAskForHumanInput,
+ actorContext: executionContext.isActingOnBehalfOfUser
+ ? executionContext.initiator
+ : undefined,
+ authContext: executionContext.authContext,
+ workspaceId,
+ userWorkspaceId,
+ ...(isDefined(application)
? {
- [ASK_QUESTION_TOOL_NAME]: createAskQuestionTool({
- isWorkspaceSetupThread: false,
- }),
- [REQUEST_FORM_TOOL_NAME]: createRequestFormTool(),
+ additionalRoleRestrictionIds: getRoleIdsFromRolePermissionConfig(
+ executionContext.rolePermissionConfig,
+ ),
+ additionalExcludedToolNames:
+ APPLICATION_BOUND_AGENT_EXCLUDED_TOOL_NAMES,
}
: {}),
- },
- canProposeToolCalls: canAskForHumanInput,
- actorContext: executionContext.isActingOnBehalfOfUser
- ? executionContext.initiator
- : undefined,
- authContext: executionContext.authContext,
- workspaceId,
- userWorkspaceId,
- ...(isDefined(application)
- ? {
- additionalRoleRestrictionIds: getRoleIdsFromRolePermissionConfig(
- executionContext.rolePermissionConfig,
- ),
- additionalExcludedToolNames:
- APPLICATION_BOUND_AGENT_EXCLUDED_TOOL_NAMES,
- }
- : {}),
- });
+ });
+ } catch (error) {
+ if (isDefined(turnId)) {
+ await recordConversation(() =>
+ this.workflowAgentConversationService.failTurn({
+ workspaceId,
+ turnId,
+ error,
+ }),
+ );
+ }
+
+ throw error;
+ }
const durationMs = Date.now() - startedAtMs;
- const recordedConversation = await recordConversation(executionResult);
+ const recordedConversation = isDefined(turnId)
+ ? await recordConversation(() =>
+ this.workflowAgentConversationService.closeTurn({
+ workspaceId,
+ threadId: conversationThread.threadId,
+ turnId,
+ workflowStep,
+ title: step.name,
+ agentId: agent?.id ?? null,
+ executionResult,
+ }),
+ )
+ : null;
await this.persistStepLog({
workflowRunId: runInfo.workflowRunId,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/workflow-agent-conversation.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/workflow-agent-conversation.workspace-service.ts
index ef5fcf2a05e..efdf0b05d87 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/workflow-agent-conversation.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/workflow-agent-conversation.workspace-service.ts
@@ -1,6 +1,7 @@
import { Injectable, Logger } from '@nestjs/common';
import { type ExtendedUIMessage } from 'twenty-shared/ai';
+import { FieldActorSource } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { WorkflowRunRecordShareService } from 'src/engine/core-modules/workflow/services/workflow-run-record-share.service';
@@ -10,7 +11,10 @@ import { AgentInboxService } from 'src/engine/metadata-modules/ai/ai-chat/servic
import { type ToolCallWorkflowStep } from 'src/engine/metadata-modules/ai/ai-chat/types/tool-call-workflow-step.type';
import { findLastMessageText } from 'src/engine/metadata-modules/ai/ai-chat/utils/find-last-message-text.util';
import { readToolCallWorkflowStep } from 'src/engine/metadata-modules/ai/ai-chat/utils/read-tool-call-workflow-step.util';
+import { mapErrorToStreamError } from 'src/engine/metadata-modules/ai/ai-chat/utils/map-error-to-stream-error.util';
import { AgentMessageRole } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-role.enum';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
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 { AgentConversationReaderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-conversation-reader.service';
@@ -65,6 +69,7 @@ export class WorkflowAgentConversationWorkspaceService {
private readonly workflowRunInboxSenderService: WorkflowRunInboxSenderWorkspaceService,
private readonly workflowRunWorkspaceService: WorkflowRunWorkspaceService,
private readonly workflowRunRecordShareService: WorkflowRunRecordShareService,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
async openConversation({
@@ -139,58 +144,65 @@ export class WorkflowAgentConversationWorkspaceService {
};
}
- async recordExecution({
- workspaceId,
+ // The turn is written before the agent runs, so a run in progress or one that
+ // fails is on record. A resumed step adds no prompt: the answer is already the
+ // last message
+ async openTurn({
+ runInfo,
threadId,
- workflowStep,
- title,
agentId,
prompt,
initiatorUserWorkspaceId,
- executionResult,
}: {
- workspaceId: string;
+ runInfo: WorkflowRunInfo;
threadId: string;
- workflowStep: ToolCallWorkflowStep;
- title: string;
agentId: string | null;
- prompt: string;
+ prompt: string | null;
initiatorUserWorkspaceId: string | null;
- executionResult: RecordableAgentExecution;
- }): Promise<RecordedConversation> {
- const turnId = await this.conversationWriterService.insertTurn({
- workspaceId,
- threadId,
- agentId,
- });
+ }): Promise<string> {
+ const { workspaceId } = runInfo;
+ const sender =
+ await this.workflowRunInboxSenderService.findRunSenderOrThrow(runInfo);
- await this.conversationWriterService.insertMessage({
+ return this.conversationWriterService.runInTransaction(
workspaceId,
- threadId,
- turnId,
- role: AgentMessageRole.USER,
- agentId: null,
- senderUserWorkspaceId: initiatorUserWorkspaceId,
- parts: [{ type: 'text', text: prompt }],
- });
+ async (scope) => {
+ const turnId = await this.conversationWriterService.insertTurn({
+ workspaceId,
+ threadId,
+ agentId,
+ status: AgentTurnStatus.RUNNING,
+ createdBy: {
+ source: FieldActorSource.WORKFLOW,
+ name: sender.workflowName,
+ workspaceMemberId: null,
+ context: {},
+ },
+ scope,
+ });
- const isAwaitingAnswer = await this.recordReply({
- workspaceId,
- threadId,
- turnId,
- workflowStep,
- title,
- agentId,
- executionResult,
- });
+ if (isDefined(prompt)) {
+ await this.conversationWriterService.insertMessage({
+ workspaceId,
+ threadId,
+ turnId,
+ role: AgentMessageRole.USER,
+ agentId: null,
+ senderUserWorkspaceId: initiatorUserWorkspaceId,
+ parts: [{ type: 'text', text: prompt }],
+ scope,
+ });
+ }
- return { threadId, isAwaitingAnswer };
+ return turnId;
+ },
+ );
}
- // The answer is already the last message, so only the agent's reply is added
- async recordContinuation({
+ async closeTurn({
workspaceId,
threadId,
+ turnId,
workflowStep,
title,
agentId,
@@ -198,16 +210,13 @@ export class WorkflowAgentConversationWorkspaceService {
}: {
workspaceId: string;
threadId: string;
+ turnId: string;
workflowStep: ToolCallWorkflowStep;
title: string;
agentId: string | null;
executionResult: RecordableAgentExecution;
}): Promise<RecordedConversation> {
- const turnId = await this.conversationWriterService.insertTurn({
- workspaceId,
- threadId,
- agentId,
- });
+ const turn = { workspaceId, threadId, turnId, execution: executionResult };
const isAwaitingAnswer = await this.recordReply({
workspaceId,
@@ -217,11 +226,40 @@ export class WorkflowAgentConversationWorkspaceService {
title,
agentId,
executionResult,
+ }).catch(async (error: unknown) => {
+ await this.turnRecorderService.finishExecutedTurn({
+ ...turn,
+ error: mapErrorToStreamError(error),
+ });
+
+ throw error;
+ });
+
+ await this.turnRecorderService.finishExecutedTurn({
+ ...turn,
+ isAwaitingAnswer,
});
return { threadId, isAwaitingAnswer };
}
+ async failTurn({
+ workspaceId,
+ turnId,
+ error,
+ }: {
+ workspaceId: string;
+ turnId: string;
+ error: unknown;
+ }): Promise<void> {
+ await this.turnRecorderService.finish({
+ workspaceId,
+ turnId,
+ status: AgentTurnStatus.FAILED,
+ error: mapErrorToStreamError(error),
+ });
+ }
+
// The wait call stays pending in the conversation until its wait resolves, then carries the outcome
async recordWaitOutcome({
workspaceId,
diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/__tests__/workflow-run.workspace-service.conversation.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/__tests__/workflow-run.workspace-service.conversation.spec.ts
index 9509d322788..27f6666e9b4 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/__tests__/workflow-run.workspace-service.conversation.spec.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/__tests__/workflow-run.workspace-service.conversation.spec.ts
@@ -1,6 +1,7 @@
import { StepStatus, WorkflowActionType } from 'twenty-shared/workflow';
import { IsNull } from 'typeorm';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
import { WorkflowRunStatus } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';
import { WorkflowRunWorkspaceService } from 'src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service';
@@ -48,6 +49,10 @@ describe('WorkflowRunWorkspaceService conversations', () => {
query: jest.fn(),
};
+ const turnRecorderService = {
+ endWaitingTurn: jest.fn().mockResolvedValue(undefined),
+ };
+
messagePartRepository.query.mockImplementation(async (_workspaceId, run) =>
run({
table: (name: string) => name,
@@ -62,6 +67,7 @@ describe('WorkflowRunWorkspaceService conversations', () => {
threadRepository as never,
messagePartRepository as never,
{ cancelRunWaits: jest.fn().mockResolvedValue(undefined) } as never,
+ turnRecorderService as never,
);
// The run lock serializes these methods with every other step write.
@@ -103,6 +109,7 @@ describe('WorkflowRunWorkspaceService conversations', () => {
workflowRun,
threadRepository,
messagePartRepository,
+ turnRecorderService,
updateWorkflowRun,
};
};
@@ -284,8 +291,12 @@ describe('WorkflowRunWorkspaceService conversations', () => {
});
it('stops its conversations waiting and closes their calls as skipped', async () => {
- const { service, threadRepository, messagePartRepository } =
- buildService();
+ const {
+ service,
+ threadRepository,
+ messagePartRepository,
+ turnRecorderService,
+ } = buildService();
await endRun(service);
@@ -298,6 +309,11 @@ describe('WorkflowRunWorkspaceService conversations', () => {
},
{ pendingQuestionMessageId: null },
);
+ expect(turnRecorderService.endWaitingTurn).toHaveBeenCalledWith({
+ workspaceId: 'workspace-id',
+ messageId: 'message-id',
+ status: AgentTurnStatus.CANCELLED,
+ });
const [[closeQuery, [partId, closedToolOutput, expectedStatus]]] =
messagePartRepository.writePart.mock.calls;
diff --git a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts
index f5ab82802d5..445c68527d3 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts
@@ -37,6 +37,8 @@ import {
WorkflowRunException,
WorkflowRunExceptionCode,
} from 'src/modules/workflow/workflow-runner/exceptions/workflow-run.exception';
+import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
+import { AgentTurnRecorderService } from 'src/engine/metadata-modules/ai/ai-history/services/agent-turn-recorder.service';
@Injectable()
export class WorkflowRunWorkspaceService {
@@ -52,6 +54,7 @@ export class WorkflowRunWorkspaceService {
@InjectAgentHistoryRepository('agentMessagePart')
private readonly messagePartRepository: AgentHistoryRepository<AgentMessagePartWorkspaceEntity>,
private readonly workflowStepWaitWorkspaceService: WorkflowStepWaitWorkspaceService,
+ private readonly turnRecorderService: AgentTurnRecorderService,
) {}
async createCoreWorkflowRun({
@@ -785,11 +788,18 @@ export class WorkflowRunWorkspaceService {
continue;
}
+ // the question is already cleared, so its calls must close before anything else can fail
await closeOpenToolParts({
messagePartRepository: this.messagePartRepository,
messageId: pendingQuestionMessageId,
workspaceId,
});
+
+ await this.turnRecorderService.endWaitingTurn({
+ workspaceId,
+ messageId: pendingQuestionMessageId,
+ status: AgentTurnStatus.CANCELLED,
+ });
}
}
diff --git a/packages/twenty-server/test/integration/endpoint-permissions/__snapshots__/endpoint-permission-declarations.integration-spec.ts.snap b/packages/twenty-server/test/integration/endpoint-permissions/__snapshots__/endpoint-permission-declarations.integration-spec.ts.snap
index 463cf41c7b7..eb149e86227 100644
--- a/packages/twenty-server/test/integration/endpoint-permissions/__snapshots__/endpoint-permission-declarations.integration-spec.ts.snap
+++ b/packages/twenty-server/test/integration/endpoint-permissions/__snapshots__/endpoint-permission-declarations.integration-spec.ts.snap
@@ -82,7 +82,7 @@ exports[`endpoint permission declarations should match the AuthPrincipalGuard an
"AgentResolver.deleteOneAgent {"applicationTarget":null,"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
"AgentResolver.findManyAgents {"applicationTarget":null,"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
"AgentResolver.findOneAgent {"applicationTarget":{"argName":"input","idKey":"id","kind":"applicationOwnedEntity","metadataName":"agent","requireApplicationRegistrationOwnership":false,"source":"graphqlArg"},"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
- "AgentResolver.updateOneAgent {"applicationTarget":null,"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
+ "AgentResolver.updateOneAgent {"applicationTarget":{"argName":"input","idKey":"id","kind":"applicationOwnedEntity","metadataName":"agent","requireApplicationRegistrationOwnership":false,"source":"graphqlArg"},"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
"AgentRunResolver.runAgent {"applicationTarget":null,"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
"AiChatUsageResolver.aiChatUsage {"applicationTarget":null,"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
"AiGenerateTextController.handleGenerateText {"applicationTarget":null,"authPrincipalGuards":[{"apiKey":true,"application":true,"oauthClient":true,"userSession":{"impersonated":true,"playground":true,"standard":true,"workspaceAgnostic":false}}]}",
diff --git a/packages/twenty-server/test/integration/graphql/suites/admin-panel/admin-chat-threads.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/admin-panel/admin-chat-threads.integration-spec.ts
index a4697ba802a..03bec3bcfb1 100644
--- a/packages/twenty-server/test/integration/graphql/suites/admin-panel/admin-chat-threads.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/admin-panel/admin-chat-threads.integration-spec.ts
@@ -131,31 +131,35 @@ describe('Admin panel global chat threads (integration)', () => {
const insertThread = async ({
id,
title,
- lastStreamError,
+ hasFailedTurn = false,
}: {
id: string;
title: string;
- lastStreamError?: object;
+ hasFailedTurn?: boolean;
}): Promise<string> => {
await insertHistory(
'agentChatThread',
- [
- 'id',
- 'workspaceMemberId',
- 'userWorkspaceId',
- 'title',
- 'lastStreamError',
- ],
- [
- id,
- workspaceMemberId,
- userWorkspaceId,
- title,
- lastStreamError ? JSON.stringify(lastStreamError) : null,
- ],
- 'ON CONFLICT (id) DO UPDATE SET "lastStreamError" = EXCLUDED."lastStreamError"',
+ ['id', 'workspaceMemberId', 'userWorkspaceId', 'title'],
+ [id, workspaceMemberId, userWorkspaceId, title],
+ 'ON CONFLICT (id) DO NOTHING',
);
+ if (hasFailedTurn) {
+ await insertHistory(
+ 'agentTurn',
+ ['id', 'threadId', 'status', 'error'],
+ [
+ randomUUID(),
+ id,
+ 'failed',
+ JSON.stringify({
+ code: 'STREAM_EXECUTION_FAILED',
+ message: 'stream failed',
+ }),
+ ],
+ );
+ }
+
seededThreadIds.push(id);
return id;
@@ -336,7 +340,7 @@ describe('Admin panel global chat threads (integration)', () => {
regularThreadId = await insertThread({
id: randomUUID(),
title: 'integration-regular-thread',
- lastStreamError: { message: 'stream failed' },
+ hasFailedTurn: true,
});
const regularAssistantMessageId = await insertMessage({
threadId: regularThreadId,
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts
index 8d9a7573e20..f34abfdacd7 100644
--- a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts
@@ -824,14 +824,21 @@ describe('core workflow visibility (e2e)', () => {
threadKey: `${workflowRunId}:trigger`,
}));
- await conversationService.recordExecution({
+ const turnId = await conversationService.openTurn({
+ runInfo: { workspaceId: SEED_APPLE_WORKSPACE_ID, workflowRunId },
+ threadId,
+ agentId: null,
+ prompt: 'Summarize the lead',
+ initiatorUserWorkspaceId: null,
+ });
+
+ await conversationService.closeTurn({
workspaceId: SEED_APPLE_WORKSPACE_ID,
threadId,
+ turnId,
workflowStep: { workflowRunId, stepId: 'trigger' },
title: 'Summarize the lead',
agentId: null,
- prompt: 'Summarize the lead',
- initiatorUserWorkspaceId: null,
executionResult: {
steps: [
{ content: [{ type: 'text', text: 'A warm lead.' }] },
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts
index 30da1176c1e..77bdd9b2964 100644
--- a/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts
@@ -185,18 +185,19 @@ describe('versioned agent history upgrade (integration)', () => {
for (const name of laterObjectNames) {
await dataSource.query(`DROP TABLE "${SCHEMA}"."${name}"`);
}
- // Their select columns leave their enum types behind the tables.
- const laterObjectEnumTypes: { typname: string }[] = await dataSource.query(
- `SELECT typname FROM pg_type JOIN pg_namespace ON pg_namespace.oid = pg_type.typnamespace
- WHERE nspname = $1 AND split_part(typname, '_', 1) = ANY($2)`,
- [SCHEMA, laterObjectNames],
- );
- for (const { typname } of laterObjectEnumTypes) {
- await dataSource.query(`DROP TYPE "${SCHEMA}"."${typname}"`);
- }
for (const { name } of [...ACTIVE_AGENT_HISTORY_TABLES].reverse()) {
await dataSource.query(`DROP TABLE "${SCHEMA}"."${name}" CASCADE`);
}
+ // Their select and actor columns leave their enum types behind the tables.
+ const droppedObjectEnumTypes: { typname: string }[] =
+ await dataSource.query(
+ `SELECT typname FROM pg_type JOIN pg_namespace ON pg_namespace.oid = pg_type.typnamespace
+ WHERE nspname = $1 AND typtype = 'e' AND split_part(typname, '_', 1) = ANY($2)`,
+ [SCHEMA, [...laterObjectNames, ...historyObjectNames]],
+ );
+ for (const { typname } of droppedObjectEnumTypes) {
+ await dataSource.query(`DROP TYPE "${SCHEMA}"."${typname}"`);
+ }
// Pre-upgrade workspaces lack the attachment side too, and the deletion above only cascades its metadata.
await dataSource.query(
'DELETE FROM core."indexMetadata" WHERE "workspaceId" = $1 AND "universalIdentifier" = $2',
diff --git a/packages/twenty-shared/src/metadata/__tests__/__snapshots__/standardObjectUniversalIdentifiers.test.ts.snap b/packages/twenty-shared/src/metadata/__tests__/__snapshots__/standardObjectUniversalIdentifiers.test.ts.snap
index 89c226de916..c1764f688de 100644
--- a/packages/twenty-shared/src/metadata/__tests__/__snapshots__/standardObjectUniversalIdentifiers.test.ts.snap
+++ b/packages/twenty-shared/src/metadata/__tests__/__snapshots__/standardObjectUniversalIdentifiers.test.ts.snap
@@ -360,18 +360,54 @@ exports[`STANDARD_OBJECTS universal identifiers should never change without an e
"agentId": {
"universalIdentifier": "4ac55a9a-95e8-4fd9-8c03-47ee3b618ae7",
},
+ "cacheCreationTokens": {
+ "universalIdentifier": "4d9feae2-2a80-43b2-965d-8ad40f129503",
+ },
+ "cacheReadTokens": {
+ "universalIdentifier": "c2bcbbf5-81ce-4679-8f08-f6a3cc00569c",
+ },
"createdAt": {
"universalIdentifier": "46926fcc-4c5b-5826-a6ca-1eb419bdf42e",
},
+ "createdBy": {
+ "universalIdentifier": "c3d5e8a2-fde8-452d-a74d-04436aaf17bc",
+ },
"deletedAt": {
"universalIdentifier": "daf50675-315c-51af-95a1-e05dd59989ce",
},
+ "endedAt": {
+ "universalIdentifier": "2b13f528-738b-402c-a033-7bbb0cce73a4",
+ },
+ "error": {
+ "universalIdentifier": "b0ed90f6-5953-4c85-aff8-407a28ec8cc7",
+ },
"id": {
"universalIdentifier": "6dd07216-fc15-54d1-ba30-2748dcf55720",
},
+ "inputCredits": {
+ "universalIdentifier": "740456a7-c0be-4bc9-8429-52dc3e3a3707",
+ },
+ "inputTokens": {
+ "universalIdentifier": "0e419986-4255-4858-b252-e6a161d55f58",
+ },
"messages": {
"universalIdentifier": "737c3559-ea1a-4269-aea4-e672b17afbb1",
},
+ "modelId": {
+ "universalIdentifier": "b1e1c27b-03dc-40b1-8052-4474c15b8233",
+ },
+ "outputCredits": {
+ "universalIdentifier": "1ca5da82-b797-43a8-a2ee-d1a062a24ca5",
+ },
+ "outputTokens": {
+ "universalIdentifier": "3e7f5fb8-f9cf-45b2-b1a7-b36c1e8ff2fd",
+ },
+ "startedAt": {
+ "universalIdentifier": "578977d7-b0d9-48d1-83f7-29ad6215a6f0",
+ },
+ "status": {
+ "universalIdentifier": "c17a4d49-f4f5-40e2-b084-11c5c4bae431",
+ },
"thread": {
"universalIdentifier": "4e9b4f1f-c1bb-42d0-bb38-eb2b2f830e64",
},
diff --git a/packages/twenty-shared/src/metadata/constants/standard-object-fields.constant.ts b/packages/twenty-shared/src/metadata/constants/standard-object-fields.constant.ts
index 349a78bb8e1..38cd4120af2 100644
--- a/packages/twenty-shared/src/metadata/constants/standard-object-fields.constant.ts
+++ b/packages/twenty-shared/src/metadata/constants/standard-object-fields.constant.ts
@@ -141,6 +141,30 @@ export const STANDARD_OBJECT_FIELDS = {
agentId: { universalIdentifier: '4ac55a9a-95e8-4fd9-8c03-47ee3b618ae7' },
thread: { universalIdentifier: '4e9b4f1f-c1bb-42d0-bb38-eb2b2f830e64' },
messages: { universalIdentifier: '737c3559-ea1a-4269-aea4-e672b17afbb1' },
+ status: { universalIdentifier: 'c17a4d49-f4f5-40e2-b084-11c5c4bae431' },
+ error: { universalIdentifier: 'b0ed90f6-5953-4c85-aff8-407a28ec8cc7' },
+ startedAt: { universalIdentifier: '578977d7-b0d9-48d1-83f7-29ad6215a6f0' },
+ endedAt: { universalIdentifier: '2b13f528-738b-402c-a033-7bbb0cce73a4' },
+ modelId: { universalIdentifier: 'b1e1c27b-03dc-40b1-8052-4474c15b8233' },
+ inputTokens: {
+ universalIdentifier: '0e419986-4255-4858-b252-e6a161d55f58',
+ },
+ outputTokens: {
+ universalIdentifier: '3e7f5fb8-f9cf-45b2-b1a7-b36c1e8ff2fd',
+ },
+ cacheReadTokens: {
+ universalIdentifier: 'c2bcbbf5-81ce-4679-8f08-f6a3cc00569c',
+ },
+ cacheCreationTokens: {
+ universalIdentifier: '4d9feae2-2a80-43b2-965d-8ad40f129503',
+ },
+ inputCredits: {
+ universalIdentifier: '740456a7-c0be-4bc9-8429-52dc3e3a3707',
+ },
+ outputCredits: {
+ universalIdentifier: '1ca5da82-b797-43a8-a2ee-d1a062a24ca5',
+ },
+ createdBy: { universalIdentifier: 'c3d5e8a2-fde8-452d-a74d-04436aaf17bc' },
},
agentMessage: {
...buildStandardObjectBaseFields(