The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(workflow): migrate MCP tools and bundled app consumers to core workflow IDs (#26189)
Thomas Trompetteb513d0edb07b
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants.tsnew file mode 100644index 00000000000..2d0653cb8c9--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants.ts@@ -0,0 +1,3 @@+export const CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER = Symbol(+ 'CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER',+);diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module.tsnew file mode 100644index 00000000000..38395efcbfa--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module.ts@@ -0,0 +1,15 @@+import { Module } from '@nestjs/common';++import { CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants';+import { appendCoreWorkflowAppOperationsToSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util';++@Module({+ providers: [+ {+ provide: CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER,+ useValue: appendCoreWorkflowAppOperationsToSdl,+ },+ ],+ exports: [CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER],+})+export class CoreWorkflowAppOperationsSdlModule {}diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type.tsnew file mode 100644index 00000000000..537a0d760dd--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type.ts@@ -0,0 +1,3 @@+export type CoreWorkflowAppOperationsSdlAppender = (+ baseSdl: string,+) => Promise<string>;diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/append-core-workflow-app-operations-to-sdl.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/append-core-workflow-app-operations-to-sdl.util.spec.tsnew file mode 100644index 00000000000..bcc04c98cbd--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/append-core-workflow-app-operations-to-sdl.util.spec.ts@@ -0,0 +1,134 @@+import { NestFactory } from '@nestjs/core';+import {+ GraphQLSchemaBuilderModule,+ GraphQLSchemaFactory,+} from '@nestjs/graphql';++import { makeExecutableSchema } from '@graphql-tools/schema';+import {+ buildSchema,+ isScalarType,+ lexicographicSortSchema,+ printType,+ validateSchema,+ type GraphQLNamedType,+ type GraphQLSchema,+} from 'graphql';++import { appendCoreWorkflowAppOperationsToSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util';+import {+ CORE_WORKFLOW_APP_MUTATION_NAMES,+ CORE_WORKFLOW_APP_QUERY_NAMES,+} from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util';+import { CoreWorkflowVersionMutationResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver';+import { CoreWorkflowResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow.resolver';++jest.setTimeout(60000);++const BASE_SDL = /* GraphQL */ `+ scalar UUID++ type Company {+ id: UUID!+ name: String+ }++ type Query {+ companies: [Company!]!+ }++ type Mutation {+ createCompany: Company+ }+`;++const describeField = (schema: GraphQLSchema, operationName: string) => {+ const field =+ schema.getQueryType()?.getFields()[operationName] ??+ schema.getMutationType()?.getFields()[operationName];++ return {+ type: field?.type.toString(),+ args: field?.args+ .map((argument) => `${argument.name}: ${argument.type.toString()}`)+ .sort(),+ };+};++describe('appendCoreWorkflowAppOperationsToSdl', () => {+ let coreSchema: GraphQLSchema;+ let mergedSchema: GraphQLSchema;++ beforeAll(async () => {+ const applicationContext = await NestFactory.createApplicationContext(+ GraphQLSchemaBuilderModule,+ { logger: false },+ );++ coreSchema = await applicationContext+ .get(GraphQLSchemaFactory)+ .create([CoreWorkflowResolver, CoreWorkflowVersionMutationResolver]);++ await applicationContext.close();++ mergedSchema = buildSchema(+ await appendCoreWorkflowAppOperationsToSdl(BASE_SDL),+ );+ });++ it('produces a valid schema that keeps the workspace operations', () => {+ expect(validateSchema(mergedSchema)).toEqual([]);+ expect(mergedSchema.getQueryType()?.getFields()).toHaveProperty(+ 'companies',+ );+ expect(mergedSchema.getMutationType()?.getFields()).toHaveProperty(+ 'createCompany',+ );+ });++ it.each([+ ...CORE_WORKFLOW_APP_QUERY_NAMES,+ ...CORE_WORKFLOW_APP_MUTATION_NAMES,+ ])(+ 'exposes %s with the signature the core schema declares',+ (operationName) => {+ const coreField = describeField(coreSchema, operationName);++ expect(coreField.type).toBeDefined();+ expect(describeField(mergedSchema, operationName)).toEqual(coreField);+ },+ );++ it('carries every referenced type over unchanged', () => {+ const coreTypeNames = Object.values(coreSchema.getTypeMap())+ .filter(+ (type: GraphQLNamedType) =>+ !type.name.startsWith('__') && !isScalarType(type),+ )+ .map((type) => type.name)+ .filter((typeName) => !['Query', 'Mutation'].includes(typeName));++ const referencedTypeNames = coreTypeNames.filter((typeName) =>+ Boolean(mergedSchema.getType(typeName)),+ );++ expect(referencedTypeNames.length).toBeGreaterThan(0);++ const sortedCoreSchema = lexicographicSortSchema(coreSchema);++ for (const typeName of referencedTypeNames) {+ const mergedType = mergedSchema.getType(typeName);+ const coreType = sortedCoreSchema.getType(typeName);++ expect(mergedType && printType(mergedType)).toEqual(+ coreType && printType(coreType),+ );+ }+ });++ it('is accepted by the sdk client generator schema builder', async () => {+ const typeDefs = await appendCoreWorkflowAppOperationsToSdl(BASE_SDL);++ expect(() => makeExecutableSchema({ typeDefs })).not.toThrow();+ });+});diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/merge-core-workflow-app-operations-into-sdl.util.spec.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/merge-core-workflow-app-operations-into-sdl.util.spec.tsnew file mode 100644index 00000000000..e184f15fea8--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/__tests__/merge-core-workflow-app-operations-into-sdl.util.spec.ts@@ -0,0 +1,134 @@+import { buildSchema, validateSchema } from 'graphql';++import { mergeCoreWorkflowAppOperationsIntoSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util';++const OPERATIONS_SDL = /* GraphQL */ `+ scalar JSON+ scalar UUID++ type CoreWorkflowDTO {+ id: UUID!+ settings: JSON+ }++ type Mutation {+ createCoreWorkflow: CoreWorkflowDTO!+ }++ type Query {+ coreWorkflows: [CoreWorkflowDTO!]!+ }+`;++const BASE_SDL_WITH_SCALARS = /* GraphQL */ `+ scalar JSON+ scalar UUID++ type Company {+ id: UUID!+ }++ type Query {+ companies: [Company!]!+ }++ type Mutation {+ createCompany: Company+ }+`;++const buildMerged = (baseSdl: string) =>+ buildSchema(+ mergeCoreWorkflowAppOperationsIntoSdl({+ baseSdl,+ operationsSdl: OPERATIONS_SDL,+ }),+ );++describe('mergeCoreWorkflowAppOperationsIntoSdl', () => {+ it('adds the operations onto the existing root types without dropping the base ones', () => {+ const schema = buildMerged(BASE_SDL_WITH_SCALARS);++ expect(validateSchema(schema)).toEqual([]);+ expect(Object.keys(schema.getQueryType()?.getFields() ?? {})).toEqual(+ expect.arrayContaining(['companies', 'coreWorkflows']),+ );+ expect(Object.keys(schema.getMutationType()?.getFields() ?? {})).toEqual(+ expect.arrayContaining(['createCompany', 'createCoreWorkflow']),+ );+ });++ it('does not redeclare a scalar the base schema already declares', () => {+ expect(() => buildMerged(BASE_SDL_WITH_SCALARS)).not.toThrow();+ });++ it('declares the scalars the base schema is missing', () => {+ const schema = buildMerged(/* GraphQL */ `+ type Query {+ placeholder: String+ }++ type Mutation {+ placeholder: String+ }+ `);++ expect(schema.getType('UUID')).toBeDefined();+ expect(schema.getType('JSON')).toBeDefined();+ });++ it('defines the root types the base schema does not declare', () => {+ const schema = buildMerged(/* GraphQL */ `+ type Query {+ placeholder: String+ }+ `);++ expect(validateSchema(schema)).toEqual([]);+ expect(schema.getMutationType()?.getFields()).toHaveProperty(+ 'createCoreWorkflow',+ );+ });++ it('leaves the base schema untouched when a root field name collides', () => {+ const baseSdl = /* GraphQL */ `+ scalar UUID++ type CoreWorkflow {+ id: UUID!+ }++ type Query {+ coreWorkflows: [CoreWorkflow!]!+ }+ `;++ expect(+ mergeCoreWorkflowAppOperationsIntoSdl({+ baseSdl,+ operationsSdl: OPERATIONS_SDL,+ }),+ ).toBe(baseSdl);+ });++ it('leaves the base schema untouched when a type name collides', () => {+ const baseSdl = /* GraphQL */ `+ scalar UUID++ type CoreWorkflowDTO {+ id: UUID!+ }++ type Query {+ placeholder: String+ }+ `;++ expect(+ mergeCoreWorkflowAppOperationsIntoSdl({+ baseSdl,+ operationsSdl: OPERATIONS_SDL,+ }),+ ).toBe(baseSdl);+ });+});diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util.tsnew file mode 100644index 00000000000..2ec5048ed01--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/append-core-workflow-app-operations-to-sdl.util.ts@@ -0,0 +1,10 @@+import { buildCoreWorkflowAppOperationsSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util';+import { mergeCoreWorkflowAppOperationsIntoSdl } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util';++export const appendCoreWorkflowAppOperationsToSdl = async (+ baseSdl: string,+): Promise<string> =>+ mergeCoreWorkflowAppOperationsIntoSdl({+ baseSdl,+ operationsSdl: await buildCoreWorkflowAppOperationsSdl(),+ });diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util.tsnew file mode 100644index 00000000000..dfe62f5e2fa--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/build-core-workflow-app-operations-sdl.util.ts@@ -0,0 +1,113 @@+import { NestFactory } from '@nestjs/core';+import {+ GraphQLSchemaBuilderModule,+ GraphQLSchemaFactory,+} from '@nestjs/graphql';++import {+ GraphQLObjectType,+ GraphQLSchema,+ isInterfaceType,+ lexicographicSortSchema,+ printSchema,+ type GraphQLFieldConfigMap,+} from 'graphql';+import { isDefined } from 'twenty-shared/utils';++import { CoreWorkflowVersionMutationResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver';+import { CoreWorkflowResolver } from 'src/engine/core-modules/workflow/resolvers/core-workflow.resolver';++export const CORE_WORKFLOW_APP_QUERY_NAMES = [+ 'coreWorkflows',+ 'coreWorkflowVersionsByCoreWorkflowId',+];++export const CORE_WORKFLOW_APP_MUTATION_NAMES = [+ 'createCoreWorkflow',+ 'updateCoreWorkflowVersionTrigger',+ 'createCoreWorkflowVersionStep',+ 'updateCoreWorkflowVersionStep',+ 'activateCoreWorkflowVersion',+];++type RootTypeConfig = ReturnType<GraphQLObjectType['toConfig']>;++const pickRootType = ({+ rootTypeConfig,+ operationNames,+}: {+ rootTypeConfig: RootTypeConfig;+ operationNames: string[];+}): GraphQLObjectType => {+ const missingOperationNames = operationNames.filter(+ (operationName) => !isDefined(rootTypeConfig.fields[operationName]),+ );++ if (missingOperationNames.length > 0) {+ throw new Error(+ `Core workflow operations missing from the ${rootTypeConfig.name} type: ${missingOperationNames.join(', ')}`,+ );+ }++ const fields: GraphQLFieldConfigMap<unknown, unknown> = Object.fromEntries(+ operationNames.map((operationName) => [+ operationName,+ rootTypeConfig.fields[operationName],+ ]),+ );++ return new GraphQLObjectType({ ...rootTypeConfig, fields });+};++const buildSlice = async (): Promise<string> => {+ const applicationContext = await NestFactory.createApplicationContext(+ GraphQLSchemaBuilderModule,+ );++ try {+ const coreSchema = await applicationContext+ .get(GraphQLSchemaFactory)+ .create([CoreWorkflowResolver, CoreWorkflowVersionMutationResolver]);++ const queryTypeConfig = coreSchema.getQueryType()?.toConfig();+ const mutationTypeConfig = coreSchema.getMutationType()?.toConfig();++ if (!isDefined(queryTypeConfig) || !isDefined(mutationTypeConfig)) {+ throw new Error(+ 'Core workflow resolvers produced no Query or Mutation type',+ );+ }++ const query = pickRootType({+ rootTypeConfig: queryTypeConfig,+ operationNames: CORE_WORKFLOW_APP_QUERY_NAMES,+ });+ const mutation = pickRootType({+ rootTypeConfig: mutationTypeConfig,+ operationNames: CORE_WORKFLOW_APP_MUTATION_NAMES,+ });++ const reachableTypes = Object.values(+ new GraphQLSchema({ query, mutation }).getTypeMap(),+ );+ const interfaceImplementations = reachableTypes+ .filter(isInterfaceType)+ .flatMap((interfaceType) => coreSchema.getPossibleTypes(interfaceType));++ return printSchema(+ lexicographicSortSchema(+ new GraphQLSchema({ query, mutation, types: interfaceImplementations }),+ ),+ );+ } finally {+ await applicationContext.close();+ }+};++let coreWorkflowAppOperationsSdlPromise: Promise<string> | undefined;++export const buildCoreWorkflowAppOperationsSdl = (): Promise<string> => {+ coreWorkflowAppOperationsSdlPromise ??= buildSlice();++ return coreWorkflowAppOperationsSdlPromise;+};diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util.tsnew file mode 100644index 00000000000..80d295ffb49--- /dev/null+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/utils/merge-core-workflow-app-operations-into-sdl.util.ts@@ -0,0 +1,90 @@+import {+ Kind,+ parse,+ print,+ type DefinitionNode,+ type DocumentNode,+} from 'graphql';+import { isDefined } from 'twenty-shared/utils';++const ROOT_TYPE_NAMES = ['Query', 'Mutation'];++const getDefinitionName = (definition: DefinitionNode): string | undefined =>+ 'name' in definition ? definition.name?.value : undefined;++const getRootFieldNames = (+ definitions: readonly DefinitionNode[],+): Set<string> =>+ new Set(+ definitions+ .filter(+ (definition) =>+ definition.kind === Kind.OBJECT_TYPE_DEFINITION &&+ ROOT_TYPE_NAMES.includes(definition.name.value),+ )+ .flatMap((definition) =>+ definition.kind === Kind.OBJECT_TYPE_DEFINITION+ ? (definition.fields ?? []).map((field) => field.name.value)+ : [],+ ),+ );++export const mergeCoreWorkflowAppOperationsIntoSdl = ({+ baseSdl,+ operationsSdl,+}: {+ baseSdl: string;+ operationsSdl: string;+}): string => {+ const baseDocument = parse(baseSdl);+ const baseDefinitionNames = new Set(+ baseDocument.definitions.map(getDefinitionName).filter(isDefined),+ );+ const baseRootFieldNames = getRootFieldNames(baseDocument.definitions);+ const operationsDocument = parse(operationsSdl);++ const hasCollidingRootField = [+ ...getRootFieldNames(operationsDocument.definitions),+ ].some((fieldName) => baseRootFieldNames.has(fieldName));++ if (hasCollidingRootField) {+ return baseSdl;+ }++ const appendedDefinitions: DefinitionNode[] = [];++ for (const definition of operationsDocument.definitions) {+ const definitionName = getDefinitionName(definition);++ if (!isDefined(definitionName)) {+ continue;+ }++ const isAlreadyDeclared = baseDefinitionNames.has(definitionName);++ if (ROOT_TYPE_NAMES.includes(definitionName)) {+ appendedDefinitions.push(+ isAlreadyDeclared && definition.kind === Kind.OBJECT_TYPE_DEFINITION+ ? { ...definition, kind: Kind.OBJECT_TYPE_EXTENSION }+ : definition,+ );+ continue;+ }++ if (!isAlreadyDeclared) {+ appendedDefinitions.push(definition);+ continue;+ }++ if (definition.kind !== Kind.SCALAR_TYPE_DEFINITION) {+ return baseSdl;+ }+ }++ const mergedDocument: DocumentNode = {+ kind: Kind.DOCUMENT,+ definitions: [...baseDocument.definitions, ...appendedDefinitions],+ };++ return print(mergedDocument);+};diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.tsindex 931d7b12b5a..209bd79b9d4 100644--- a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.ts+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.module.ts@@ -1,6 +1,7 @@import { Module } from '@nestjs/common';import { ScalarsExplorerService } from 'src/engine/api/graphql/services/scalars-explorer.service';+import { CoreWorkflowAppOperationsSdlModule } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.module';import { WorkspaceSchemaBuilderModule } from 'src/engine/api/graphql/workspace-schema-builder/workspace-schema-builder.module';import { WorkspaceGraphqlSchemaSDLService } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service';import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';@@ -11,6 +12,7 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/WorkspaceSchemaBuilderModule,WorkspaceCacheStorageModule,WorkspaceManyOrAllFlatEntityMapsCacheModule,+ CoreWorkflowAppOperationsSdlModule,],providers: [WorkspaceGraphqlSchemaSDLService, ScalarsExplorerService],exports: [WorkspaceGraphqlSchemaSDLService],diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.tsindex 7770663d49b..ea277cab207 100644--- a/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts+++ b/packages/twenty-server/src/engine/api/graphql/workspace-graphql-schema-sdl/workspace-graphql-schema-sdl.service.ts@@ -1,10 +1,12 @@-import { Injectable } from '@nestjs/common';+import { Inject, Injectable } from '@nestjs/common';import { isNonEmptyString } from '@sniptt/guards';import { printSchema } from 'graphql';import { isDefined } from 'twenty-shared/utils';import { ScalarsExplorerService } from 'src/engine/api/graphql/services/scalars-explorer.service';+import { CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/core-workflow-app-operations-sdl.constants';+import { type CoreWorkflowAppOperationsSdlAppender } from 'src/engine/api/graphql/workspace-graphql-schema-sdl/types/core-workflow-app-operations-sdl-appender.type';import { type SchemaGenerationContext } from 'src/engine/api/graphql/workspace-schema-builder/types/schema-generation-context.type';import { WorkspaceGraphQLSchemaGenerator } from 'src/engine/api/graphql/workspace-schema-builder/workspace-graphql-schema.factory';import { FlatWorkspace } from 'src/engine/core-modules/workspace/types/flat-workspace.type';@@ -38,6 +40,8 @@ export class WorkspaceGraphqlSchemaSDLService {private readonly workspaceGraphQLSchemaGenerator: WorkspaceGraphQLSchemaGenerator,private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,+ @Inject(CORE_WORKFLOW_APP_OPERATIONS_SDL_APPENDER)+ private readonly appendCoreWorkflowAppOperationsToSdl: CoreWorkflowAppOperationsSdlAppender,) {}async getOrComputeSchemaSDL(@@ -148,7 +152,9 @@ export class WorkspaceGraphqlSchemaSDLService {});return {- sdl,+ sdl: isDefined(applicationId)+ ? await this.appendCoreWorkflowAppOperationsToSdl(sdl)+ : sdl,usedScalarNames,flatObjectMetadataMaps,flatFieldMetadataMaps,diff --git a/packages/twenty-server/src/engine/core-modules/actor/utils/__tests__/build-actor-metadata-from-principal.util.spec.ts b/packages/twenty-server/src/engine/core-modules/actor/utils/__tests__/build-actor-metadata-from-principal.util.spec.tsnew file mode 100644index 00000000000..35d35863358--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/actor/utils/__tests__/build-actor-metadata-from-principal.util.spec.ts@@ -0,0 +1,40 @@+import { FieldActorSource } from 'twenty-shared/types';++import { buildActorMetadataFromPrincipal } from 'src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util';+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';++const WORKSPACE_MEMBER = {+ id: '20202020-0687-4c41-b707-ed1bfca972a7',+ name: { firstName: 'Tim', lastName: 'Apple' },+} satisfies Pick<WorkspaceMemberWorkspaceEntity, 'id' | 'name'>;++const APPLICATION = {+ id: '20202020-1c25-4d02-bf25-6aeccf7ea419',+ name: 'People Data Labs',+} as FlatApplication;++describe('buildActorMetadataFromPrincipal', () => {+ it('attributes to the workspace member when there is one', () => {+ const actor = buildActorMetadataFromPrincipal({+ workspaceMember: WORKSPACE_MEMBER,+ application: APPLICATION,+ });++ expect(actor?.workspaceMemberId).toBe(WORKSPACE_MEMBER.id);+ expect(actor?.source).toBe(FieldActorSource.MANUAL);+ });++ it('falls back to the application when no workspace member is authenticated', () => {+ const actor = buildActorMetadataFromPrincipal({+ application: APPLICATION,+ });++ expect(actor?.workspaceMemberId).toBeNull();+ expect(actor?.name).toBe(APPLICATION.name);+ });++ it('returns undefined when neither principal is present', () => {+ expect(buildActorMetadataFromPrincipal({})).toBeUndefined();+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util.ts b/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util.tsnew file mode 100644index 00000000000..dd82bfa46a5--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util.ts@@ -0,0 +1,31 @@+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 { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';++export const buildActorMetadataFromPrincipal = ({+ workspaceMember,+ application,+}: {+ workspaceMember?: Pick<WorkspaceMemberWorkspaceEntity, 'id' | 'name'>;+ application?: FlatApplication;+}): ActorMetadata | undefined => {+ if (isDefined(workspaceMember)) {+ return buildCreatedByFromFullNameMetadata({+ fullNameMetadata: {+ firstName: workspaceMember.name.firstName,+ lastName: workspaceMember.name.lastName,+ },+ workspaceMemberId: workspaceMember.id,+ });+ }++ if (isDefined(application)) {+ return buildCreatedByFromApplication({ application });+ }++ return undefined;+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.tsindex eaeca3de976..b01170551dc 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-all-flat-entity-operation-record-by-metadata-name-from-from-to.util.spec.ts@@ -237,6 +237,19 @@ describe('buildAllFlatEntityOperationRecordByMetadataNameFromFromTo', () => {expect(result.commandMenuItem?.flatEntityToDelete).toBeUndefined();});+ it('does not delete a workflow trigger command that only carries its core pointer', () => {+ const result = inferDeletionOf(+ withCommandMenuItem({+ ...COMMAND_MENU_ITEM,+ engineComponentKey: EngineComponentKey.TRIGGER_WORKFLOW_VERSION,+ workflowVersionId: null,+ coreWorkflowVersionId: 'a-core-workflow-version-id',+ }),+ );++ expect(result.commandMenuItem?.flatEntityToDelete).toBeUndefined();+ });+it('does not delete a command without the front component its manifest requires', () => {const result = inferDeletionOf(withCommandMenuItem(COMMAND_MENU_ITEM));diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.tsindex ac8a75135f0..a1c317cb3ef 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/classify-application-flat-entities.util.spec.ts@@ -1,6 +1,11 @@-import { FieldMetadataType } from 'twenty-shared/types';+import {+ CommandMenuItemAvailabilityType,+ FieldMetadataType,+} from 'twenty-shared/types';import { classifyApplicationFlatEntities } from 'src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util';+import { EngineComponentKey } from 'src/engine/metadata-modules/command-menu-item/enums/engine-component-key.enum';+import { type FlatCommandMenuItem } from 'src/engine/metadata-modules/flat-command-menu-item/types/flat-command-menu-item.type';import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';@@ -231,3 +236,90 @@ describe('classifyApplicationFlatEntities', () => {expect(keys).toEqual([...keys].sort());});});++const COMMAND_MENU_ITEM_UID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';++const buildWorkflowCommandMenuItem = ({+ workflowVersionId,+ coreWorkflowVersionId,+}: {+ workflowVersionId: string | null;+ coreWorkflowVersionId: string | null;+}): FlatCommandMenuItem =>+ ({+ id: 'command-menu-item-id',+ universalIdentifier: COMMAND_MENU_ITEM_UID,+ applicationId: APP_ID,+ applicationUniversalIdentifier: APP_UID,+ workflowVersionId,+ coreWorkflowVersionId,+ frontComponentId: null,+ frontComponentUniversalIdentifier: null,+ engineComponentKey: EngineComponentKey.TRIGGER_WORKFLOW_VERSION,+ label: 'Run workflow',+ availabilityType: CommandMenuItemAvailabilityType.GLOBAL,+ isSystemSideEffect: false,+ deletedAt: null,+ createdAt: NOW,+ updatedAt: NOW,+ }) as unknown as FlatCommandMenuItem;++const classifyCommandMenuItem = (flatCommandMenuItem: FlatCommandMenuItem) => {+ const maps = createEmptyAllFlatEntityMaps();++ maps.flatCommandMenuItemMaps = addFlatEntityToFlatEntityMapsOrThrow({+ flatEntity: flatCommandMenuItem,+ flatEntityMaps: maps.flatCommandMenuItemMaps,+ });++ return classifyApplicationFlatEntities({+ flatApplication,+ allFlatEntityMaps: maps,+ applicationAllFlatEntityMaps: maps,+ reconstructedCoverage: [],+ }).find((entry) => entry.universalIdentifier === COMMAND_MENU_ITEM_UID);+};++describe('classifyApplicationFlatEntities workflow commands', () => {+ it('should exclude a workflow command that carries both pointers', () => {+ expect(+ classifyCommandMenuItem(+ buildWorkflowCommandMenuItem({+ workflowVersionId: 'a-workflow-version-id',+ coreWorkflowVersionId: 'a-core-workflow-version-id',+ }),+ ),+ ).toMatchObject({+ status: ApplicationExportCoverageStatus.EXCLUDED,+ reason: 'workflow trigger command',+ });+ });++ it('should exclude a workflow command that only carries its core pointer', () => {+ expect(+ classifyCommandMenuItem(+ buildWorkflowCommandMenuItem({+ workflowVersionId: null,+ coreWorkflowVersionId: 'a-core-workflow-version-id',+ }),+ ),+ ).toMatchObject({+ status: ApplicationExportCoverageStatus.EXCLUDED,+ reason: 'workflow trigger command',+ });+ });++ it('should not treat a command without any workflow pointer as workflow-generated', () => {+ expect(+ classifyCommandMenuItem(+ buildWorkflowCommandMenuItem({+ workflowVersionId: null,+ coreWorkflowVersionId: null,+ }),+ ),+ ).toMatchObject({+ status: ApplicationExportCoverageStatus.EXCLUDED,+ reason: 'command without front component',+ });+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.tsindex 0e977a0bd47..706d9b4bbd5 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/can-manifest-express-flat-entity.util.ts@@ -9,6 +9,7 @@ const WORKSPACE_BOUND_PROPERTIES = ['userWorkspaceId','apiKeyId','workflowVersionId',+ 'coreWorkflowVersionId','targetRecordId',] as const;diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.tsindex 4cdfbc9d2f1..513a355b45b 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts@@ -43,6 +43,14 @@ const getFlatEntities = ({const isSoftDeleted = (flatEntity: ApplicationFlatEntity): boolean =>'deletedAt' in flatEntity && isDefined(flatEntity.deletedAt);+const isWorkflowTriggerCommandMenuItem = (+ flatEntity: ApplicationFlatEntity,+): boolean =>+ ('workflowVersionId' in flatEntity &&+ isDefined(flatEntity.workflowVersionId)) ||+ ('coreWorkflowVersionId' in flatEntity &&+ isDefined(flatEntity.coreWorkflowVersionId));+const classifyFlatEntity = ({metadataName,flatEntity,@@ -79,10 +87,7 @@ const classifyFlatEntity = ({}: { status: ApplicationExportCoverageStatus.UNSUPPORTED };case 'commandMenuItem':- if (- 'workflowVersionId' in flatEntity &&- isDefined(flatEntity.workflowVersionId)- ) {+ if (isWorkflowTriggerCommandMenuItem(flatEntity)) {return {status: ApplicationExportCoverageStatus.EXCLUDED,reason: 'workflow trigger command',diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.tsindex 4fdba2b6edc..4a8481b0974 100644--- a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.ts+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/workflow-tool.provider.ts@@ -94,9 +94,11 @@ export class WorkflowToolProvider implements ToolProvider {return null;}- return this.workflowToolService.generateWorkflowTools(- context.workspaceId,- context.rolePermissionConfig,- );+ return this.workflowToolService.generateWorkflowTools({+ workspaceId: context.workspaceId,+ rolePermissionConfig: context.rolePermissionConfig,+ actorContext: context.actorContext,+ userWorkspaceId: context.userWorkspaceId,+ });}}diff --git a/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.ts b/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.tsnew file mode 100644index 00000000000..19b2d06baa6--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/workflow/core-workflow-services.module.ts@@ -0,0 +1,69 @@+import { Module } from '@nestjs/common';+import { TypeOrmModule } from '@nestjs/typeorm';++import { CacheLockModule } from 'src/engine/core-modules/cache-lock/cache-lock.module';+import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-storage.module';+import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';+import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';+import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';+import { CoreWorkflowAccessModule } from 'src/engine/core-modules/workflow/core-workflow-access.module';+import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';+import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';+import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';+import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';+import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';+import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';+import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';+import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';+import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';+import { CommandMenuItemModule } from 'src/engine/metadata-modules/command-menu-item/command-menu-item.module';+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';+import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';+import { WorkflowMetadataReadModule } from 'src/modules/workflow/common/workspace-services/workflow-metadata-read.module';+import { WorkflowBuilderModule } from 'src/modules/workflow/workflow-builder/workflow-builder.module';+import { WorkflowVersionValidationModule } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.module';+import { CodeStepBuildModule } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/code-step-build.module';+import { WorkflowRunnerModule } from 'src/modules/workflow/workflow-runner/workflow-runner.module';+import { AutomatedTriggerModule } from 'src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module';++@Module({+ imports: [+ CoreWorkflowAccessModule,+ TypeOrmModule.forFeature([WorkspaceEntity, WorkflowVersionEntity]),+ AutomatedTriggerModule,+ CacheLockModule,+ CacheStorageModule,+ CodeStepBuildModule,+ CommandMenuItemModule,+ RecordPositionModule,+ WorkflowBuilderModule,+ WorkflowCommonModule,+ WorkflowCoreModule,+ WorkflowMetadataReadModule,+ WorkflowRunnerModule,+ WorkflowVersionCoreModule,+ WorkflowVersionValidationModule,+ ],+ providers: [+ CoreWorkflowIdResolutionService,+ CoreWorkflowLifecycleWorkspaceService,+ CoreWorkflowListService,+ CoreWorkflowMutationWorkspaceService,+ CoreWorkflowVersionListService,+ CoreWorkflowVersionMutationWorkspaceService,+ CoreWorkflowVersionWriteService,+ provideWorkspaceScopedRepository(WorkflowVersionEntity),+ provideWorkspaceScopedRepository(WorkflowEntity),+ ],+ exports: [+ CoreWorkflowIdResolutionService,+ CoreWorkflowLifecycleWorkspaceService,+ CoreWorkflowListService,+ CoreWorkflowMutationWorkspaceService,+ CoreWorkflowVersionListService,+ CoreWorkflowVersionMutationWorkspaceService,+ CoreWorkflowVersionWriteService,+ ],+})+export class CoreWorkflowServicesModule {}diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.tsindex 8bee85ca054..4c01fbef5e6 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow-version-mutation.resolver.ts@@ -37,6 +37,7 @@ import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspimport { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';import { UserAuthGuard } from 'src/engine/guards/user-auth.guard';+import { UserOrApplicationAuthGuard } from 'src/engine/guards/user-or-application-auth.guard';import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';@@ -49,7 +50,7 @@ import { CoreWorkflowRunnerService } from 'src/modules/workflow/workflow-runner/@UsePipes(ResolverValidationPipe)@UseGuards(WorkspaceAuthGuard,- UserAuthGuard,+ UserOrApplicationAuthGuard,SettingsPermissionGuard(PermissionFlagType.WORKFLOWS),)@UseFilters(@@ -125,6 +126,7 @@ export class CoreWorkflowVersionMutationResolver {}@Mutation(() => RunWorkflowVersionDTO)+ @UseGuards(UserAuthGuard)async runCoreWorkflowVersion(@AuthUser() user: AuthContextUser,@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,diff --git a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.tsindex 21187edf58a..1e02f9e6e55 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/resolvers/core-workflow.resolver.ts@@ -1,7 +1,9 @@import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';import { Args, Mutation, Query } from '@nestjs/graphql';+import { msg } from '@lingui/core/macro';import { PermissionFlagType } from 'twenty-shared/constants';+import { type ActorMetadata } from 'twenty-shared/types';import { CoreResolver } from 'src/engine/api/graphql/graphql-config/decorators/core-resolver.decorator';import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';@@ -30,15 +32,22 @@ import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/servicimport { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';-import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';-import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';+import { buildActorMetadataFromPrincipal } from 'src/engine/core-modules/actor/utils/build-actor-metadata-from-principal.util';+import {+ WorkflowQueryValidationException,+ WorkflowQueryValidationExceptionCode,+} from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';+import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';+import { AuthWorkspaceMember } from 'src/engine/decorators/auth/auth-workspace-member.decorator';import { isDefined } from 'twenty-shared/utils';import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';-import { UserAuthGuard } from 'src/engine/guards/user-auth.guard';+import { UserOrApplicationAuthGuard } from 'src/engine/guards/user-or-application-auth.guard';import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';@@ -46,7 +55,7 @@ import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-module@UsePipes(ResolverValidationPipe)@UseGuards(WorkspaceAuthGuard,- UserAuthGuard,+ UserOrApplicationAuthGuard,SettingsPermissionGuard(PermissionFlagType.WORKFLOWS),)@UseFilters(@@ -62,6 +71,25 @@ export class CoreWorkflowResolver {private readonly coreWorkflowVersionListService: CoreWorkflowVersionListService,) {}+ private resolveCreatedByOrThrow(principal: {+ workspaceMember?: WorkspaceMemberWorkspaceEntity;+ application?: FlatApplication;+ }): ActorMetadata {+ const createdBy = buildActorMetadataFromPrincipal(principal);++ if (!isDefined(createdBy)) {+ throw new WorkflowQueryValidationException(+ 'No authenticated actor to attribute the workflow to',+ WorkflowQueryValidationExceptionCode.FORBIDDEN,+ {+ userFriendlyMessage: msg`Authentication is required to perform this action`,+ },+ );+ }++ return createdBy;+ }+@Mutation(() => CoreWorkflowDTO, { nullable: true })async updateCoreWorkflow(@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,@@ -98,9 +126,13 @@ export class CoreWorkflowResolver {@Mutation(() => CoreWorkflowDTO)async duplicateCoreWorkflow(@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,+ @AuthWorkspaceMember() workspaceMember:+ | WorkspaceMemberWorkspaceEntity+ | undefined,+ @AuthApplication({ allowUndefined: true })+ application: FlatApplication | undefined,@AuthUserWorkspaceId({ allowUndefined: true })userWorkspaceId: string | undefined,- @AuthUser() user: AuthContextUser,@Args('input'){coreWorkflowIdToDuplicate,@@ -109,8 +141,8 @@ export class CoreWorkflowResolver {): Promise<CoreWorkflowDTO> {return this.coreWorkflowMutationWorkspaceService.duplicateWorkflow({workspaceId,+ createdBy: this.resolveCreatedByOrThrow({ workspaceMember, application }),userWorkspaceId,- user,coreWorkflowIdToDuplicate,coreWorkflowVersionIdToCopy,});@@ -119,15 +151,19 @@ export class CoreWorkflowResolver {@Mutation(() => CoreWorkflowDTO)async createCoreWorkflow(@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,+ @AuthWorkspaceMember() workspaceMember:+ | WorkspaceMemberWorkspaceEntity+ | undefined,+ @AuthApplication({ allowUndefined: true })+ application: FlatApplication | undefined,@AuthUserWorkspaceId({ allowUndefined: true })userWorkspaceId: string | undefined,- @AuthUser() user: AuthContextUser,@Args('input') input: CreateCoreWorkflowInput,): Promise<CoreWorkflowDTO> {return this.coreWorkflowMutationWorkspaceService.createWorkflow({workspaceId,+ createdBy: this.resolveCreatedByOrThrow({ workspaceMember, application }),userWorkspaceId,- user,...input,});}diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.tsindex 1ca49dadc81..6fa117186b6 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service.ts@@ -2,12 +2,10 @@ import { Injectable, Logger } from '@nestjs/common';import { Equal, In, IsNull, Or } from 'typeorm';import { msg } from '@lingui/core/macro';-import { WorkflowVisibility } from 'twenty-shared/types';+import { type ActorMetadata, WorkflowVisibility } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import { v4 as uuidv4 } from 'uuid';-import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';-import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';import { type CoreWorkflowDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow.dto';import { type DeletedCoreWorkflowDTO } from 'src/engine/core-modules/workflow/dtos/deleted-core-workflow.dto';@@ -44,7 +42,6 @@ import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workimport { remapDuplicatedStepDestinations } from 'src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util';import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service';import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';-import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';@Injectable()export class CoreWorkflowMutationWorkspaceService {@@ -72,14 +69,14 @@ export class CoreWorkflowMutationWorkspaceService {async duplicateWorkflow({workspaceId,+ createdBy,userWorkspaceId,- user,coreWorkflowIdToDuplicate,coreWorkflowVersionIdToCopy,}: {workspaceId: string;+ createdBy: ActorMetadata;userWorkspaceId: string | undefined;- user: AuthContextUser;coreWorkflowIdToDuplicate: string;coreWorkflowVersionIdToCopy: string;}): Promise<CoreWorkflowDTO> {@@ -131,8 +128,8 @@ export class CoreWorkflowMutationWorkspaceService {const duplicatedWorkflow = await this.createWorkflow({workspaceId,+ createdBy,userWorkspaceId,- user,name: `${sourceCoreWorkflow.name ?? ''} (Duplicate)`,// duplicating a private workflow must not publish it to the workspacevisibility: sourceCoreWorkflow.visibility,@@ -354,14 +351,14 @@ export class CoreWorkflowMutationWorkspaceService {async createWorkflow({workspaceId,+ createdBy,userWorkspaceId,- user,name,visibility,}: {workspaceId: string;+ createdBy: ActorMetadata;userWorkspaceId: string | undefined;- user: AuthContextUser;name?: string;visibility?: WorkflowVisibility;}): Promise<CoreWorkflowDTO> {@@ -372,19 +369,6 @@ export class CoreWorkflowMutationWorkspaceService {const authContext = buildSystemAuthContext(workspaceId);- const workspaceMember =- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workspaceMemberRepository =- this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(- 'workspaceMember',- { shouldBypassPermissionChecks: true },- );-- return workspaceMemberRepository.findOneOrFail({- where: { userId: user.id },- });- }, authContext);-const workspaceWorkflowId = uuidv4();const coreWorkflow = await this.coreWorkflowRepository.insertAndReturnOne(@@ -422,13 +406,7 @@ export class CoreWorkflowMutationWorkspaceService {name: name ?? null,position,coreWorkflowId: coreWorkflow.id,- createdBy: buildCreatedByFromFullNameMetadata({- fullNameMetadata: {- firstName: workspaceMember.name.firstName,- lastName: workspaceMember.name.lastName,- },- workspaceMemberId: workspaceMember.id,- }),+ createdBy,});}, authContext);diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.tsindex 175144fe070..4c837fa5a7a 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-list.service.ts@@ -4,7 +4,10 @@ import { InjectDataSource } from '@nestjs/typeorm';import { isDefined } from 'twenty-shared/utils';import { DataSource } from 'typeorm';-import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';+import {+ WorkflowVersionEntity,+ WorkflowVersionStatus as CoreWorkflowVersionStatus,+} from 'src/engine/core-modules/workflow/entities/workflow-version.entity';import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';import { type CoreWorkflowVersionDTO } from 'src/engine/core-modules/workflow/dtos/core-workflow-version.dto';import { CoreWorkflowAccessService } from 'src/engine/core-modules/workflow/services/core-workflow-access.service';@@ -166,6 +169,17 @@ export class CoreWorkflowVersionListService {.reverse();}+ async findDraftCoreWorkflowVersions({+ workspaceId,+ }: {+ workspaceId: string;+ }): Promise<Pick<WorkflowVersionEntity, 'id' | 'steps'>[]> {+ return this.coreWorkflowVersionRepository.find(workspaceId, {+ where: { status: CoreWorkflowVersionStatus.DRAFT },+ select: { id: true, steps: true },+ });+ }+async findOneByCoreWorkflowVersionId({workspaceId,userWorkspaceId,diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.tsindex 78324f18af7..ec8fee45d29 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service.ts@@ -35,6 +35,7 @@ import {WorkflowVersionStepException,WorkflowVersionStepExceptionCode,} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';+import { computeWorkflowStepPositions } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util';import { computeWorkflowVersionStepChanges } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-version-step-updates.util';import { WorkflowSchemaWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service';import {@@ -656,6 +657,31 @@ export class CoreWorkflowVersionMutationWorkspaceService {});}+ async autoLayoutCoreWorkflowVersion({+ workspaceId,+ userWorkspaceId,+ coreWorkflowVersionId,+ }: {+ workspaceId: string;+ userWorkspaceId: string | undefined;+ coreWorkflowVersionId: string;+ }): Promise<void> {+ const { trigger, steps } =+ await this.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(+ { workspaceId, userWorkspaceId, coreWorkflowVersionId },+ );++ await this.updatePositions({+ workspaceId,+ userWorkspaceId,+ coreWorkflowVersionId,+ positions: computeWorkflowStepPositions({+ trigger,+ steps: steps ?? [],+ }),+ });+ }+@WithLock('coreWorkflowId')async createDraftFromCoreWorkflowVersion({workspaceId,diff --git a/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.ts b/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.tsindex 38baff09c01..734a296722c 100644--- a/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.ts+++ b/packages/twenty-server/src/engine/core-modules/workflow/workflow-api.module.ts@@ -17,14 +17,8 @@ import { WorkflowVersionResolver } from 'src/engine/core-modules/workflow/resolvimport { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';import { WorkflowEntity } from 'src/engine/core-modules/workflow/entities/workflow.entity';import { CoreWorkflowAccessModule } from 'src/engine/core-modules/workflow/core-workflow-access.module';-import { CoreWorkflowIdResolutionService } from 'src/engine/core-modules/workflow/services/core-workflow-id-resolution.service';-import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';-import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';-import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';-import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';-import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';+import { CoreWorkflowServicesModule } from 'src/engine/core-modules/workflow/core-workflow-services.module';import { WorkflowCoreModule } from 'src/engine/core-modules/workflow/workflow-core.module';-import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';import { WorkflowVersionEntity } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';@@ -69,6 +63,7 @@ import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/worConnectedAccountMetadataModule,WorkflowVersionCoreModule,WorkflowVersionValidationModule,+ CoreWorkflowServicesModule,],controllers: [WorkflowTriggerController],providers: [@@ -79,13 +74,6 @@ import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/worWorkflowVersionResolver,CoreWorkflowResolver,CoreWorkflowVersionMutationResolver,- CoreWorkflowIdResolutionService,- CoreWorkflowLifecycleWorkspaceService,- CoreWorkflowListService,- CoreWorkflowMutationWorkspaceService,- CoreWorkflowVersionMutationWorkspaceService,- CoreWorkflowVersionWriteService,- CoreWorkflowVersionListService,provideWorkspaceScopedRepository(WorkflowVersionEntity),provideWorkspaceScopedRepository(WorkflowEntity),],diff --git a/packages/twenty-server/src/engine/decorators/auth/auth-workspace-member.decorator.ts b/packages/twenty-server/src/engine/decorators/auth/auth-workspace-member.decorator.tsnew file mode 100644index 00000000000..aa85a1dcd97--- /dev/null+++ b/packages/twenty-server/src/engine/decorators/auth/auth-workspace-member.decorator.ts@@ -0,0 +1,11 @@+import { type ExecutionContext, createParamDecorator } from '@nestjs/common';++import { getRequest } from 'src/utils/extract-request';++export const AuthWorkspaceMember = createParamDecorator(+ (_data: unknown, ctx: ExecutionContext) => {+ const request = getRequest(ctx);++ return request.workspaceMember;+ },+);diff --git a/packages/twenty-server/src/engine/guards/user-or-application-auth.guard.ts b/packages/twenty-server/src/engine/guards/user-or-application-auth.guard.tsnew file mode 100644index 00000000000..37e2dd74dea--- /dev/null+++ b/packages/twenty-server/src/engine/guards/user-or-application-auth.guard.ts@@ -0,0 +1,17 @@+import { type CanActivate, type ExecutionContext } from '@nestjs/common';++import { isDefined } from 'twenty-shared/utils';++import { getRequestOrThrowWhenUnauthenticated } from 'src/engine/guards/utils/get-request-or-throw-when-unauthenticated.util';++export class UserOrApplicationAuthGuard implements CanActivate {+ canActivate(context: ExecutionContext): boolean {+ const request = getRequestOrThrowWhenUnauthenticated(context);++ if (!request) {+ return false;+ }++ return isDefined(request.user) || isDefined(request.application);+ }+}diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.tsindex 416acb07c6f..ca9b5edd36e 100644--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.ts+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/skill-metadata/create-standard-flat-skill-metadata.util.ts@@ -66,18 +66,18 @@ LOGIC_FUNCTION steps execute logic functions provided by installed applications.1. Call \`list_logic_function_tools\` to discover available logic function tools with their IDs.2. Use \`create_workflow_version_step\` with stepType "LOGIC_FUNCTION" and pass the logicFunctionId in defaultSettings:- { "stepType": "LOGIC_FUNCTION", "workflowVersionId": "<version-id>", "defaultSettings": { "input": { "logicFunctionId": "<logic-function-id>" } } }+ { "stepType": "LOGIC_FUNCTION", "coreWorkflowVersionId": "<core-version-id>", "defaultSettings": { "input": { "logicFunctionId": "<logic-function-id>" } } }3. Or when using \`create_complete_workflow\`, include a step with type "LOGIC_FUNCTION" and settings.input.logicFunctionId.## Listing Workflows-To discover existing workflows in the workspace, use \`list_workflows\`. Use this before modifying a workflow when the user refers to it by name rather than id — resolve the \`id\` here first, then call \`get_workflow_current_version\` with it.+To discover existing workflows in the workspace, use \`list_workflows\`. Use this before modifying a workflow when the user refers to it by name rather than id — resolve the \`coreWorkflowId\` here first, then call \`get_workflow_current_version\` with it.## Deleting Workflows-To delete a workflow entirely, use \`delete_workflow\` with its \`workflowId\`. This also removes the workflow's versions, runs and automated triggers, and deactivates any active version — it is a destructive, irreversible operation.+To delete a workflow entirely, use \`delete_workflow\` with its \`coreWorkflowId\`. This also removes the workflow's versions, runs and automated triggers, and deactivates any active version — it is a destructive, irreversible operation.-- If the user refers to the workflow by name, resolve its \`workflowId\` with \`list_workflows\` first.+- If the user refers to the workflow by name, resolve its \`coreWorkflowId\` with \`list_workflows\` first.- IMPORTANT : Always confirm with the user before deleting, and make sure you are deleting the correct workflow.- To simply stop a workflow from running without removing it, prefer \`deactivate_workflow_version\` instead of deleting.@@ -85,19 +85,19 @@ To delete a workflow entirely, use \`delete_workflow\` with its \`workflowId\`.When a user reports a failing or misbehaving workflow, diagnose it with two read-only tools:-- \`list_workflow_runs\`: lists runs (optional \`workflowId\`, optional \`status\`, optional \`limit\`), most recent first. Each result carries \`id\`, \`name\`, \`status\`, run-level \`error\`, \`startedAt\`, \`endedAt\`, \`workflowId\`, and \`workflowVersionId\`.+- \`list_workflow_runs\`: lists runs (optional \`coreWorkflowId\`, optional \`status\`, optional \`limit\`), most recent first. Each result carries the run \`id\`, \`name\`, \`status\`, run-level \`error\`, \`startedAt\`, \`endedAt\`, \`coreWorkflowId\`, and \`coreWorkflowVersionId\`.- \`get_workflow_run\`: returns full details for one run (\`workflowRunId\`) — overall status, run-level error, every step's status/error, and the execution logs of the steps that failed.### Resolving the run when no id is given-For requests like "fix my latest failed workflow" where no run or workflow id is provided, call \`list_workflow_runs\` with \`status\` "FAILED" and NO \`workflowId\` — this returns the most recent failed run across all workflows, and each result already carries \`workflowId\`, \`workflowVersionId\`, and a human-readable \`name\`, so you never need an id from the user. If the user names a specific workflow, resolve its \`workflowId\` first and pass it as a filter.+For requests like "fix my latest failed workflow" where no run or workflow id is provided, call \`list_workflow_runs\` with \`status\` "FAILED" and NO \`coreWorkflowId\` — this returns the most recent failed run across all workflows, and each result already carries \`coreWorkflowId\`, \`coreWorkflowVersionId\`, and a human-readable \`name\`, so you never need an id from the user. If the user names a specific workflow, resolve its \`coreWorkflowId\` first and pass it as a filter.### Flow-1. Identify the run via \`list_workflow_runs\` (use \`limit\` 5 when no \`workflowId\` so you can detect multiple failing workflows).-2. If results span multiple \`workflowId\`s, disambiguate by name with the user before editing anything.+1. Identify the run via \`list_workflow_runs\` (use \`limit\` 5 when no \`coreWorkflowId\` so you can detect multiple failing workflows).+2. If results span multiple \`coreWorkflowId\`s, disambiguate by name with the user before editing anything.3. Call \`get_workflow_run\` on the chosen run id to read the failed step(s) and their error/logs.-4. Map back to the workflow definition via \`get_workflow_current_version(workflowId)\`, then propose or apply a fix.+4. Map back to the workflow definition via \`get_workflow_current_version(coreWorkflowId)\`, then propose or apply a fix.## PICK_RECORD StepsPICK_RECORD selects one record from a candidate pool (settings.input.recordIds) and outputs it for later steps to reference — useful for assignment workflows like picking an owner. Set settings.input.strategy to RANDOM, ROUND_ROBIN, or LOAD_BALANCED; LOAD_BALANCED also needs settings.input.loadBalance.{objectNameSingular, fieldName} to pick the candidate with the fewest related records.diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util.tsnew file mode 100644index 00000000000..16d377a2f1c--- /dev/null+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util.ts@@ -0,0 +1,36 @@+import {+ buildWorkflowGraph,+ computeWorkflowLayout,+ TRIGGER_STEP_ID,+ WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,+} from 'twenty-shared/workflow';++import { type WorkflowStepPositionUpdateInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-step-position-update.input';+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';+import { type WorkflowTrigger } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';++export const computeWorkflowStepPositions = ({+ trigger,+ steps,+}: {+ trigger: WorkflowTrigger | null;+ steps: WorkflowAction[];+}): WorkflowStepPositionUpdateInput[] => {+ const { childrenByStepId } = buildWorkflowGraph({ trigger, steps });++ const nodes = [+ { id: TRIGGER_STEP_ID, ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS },+ ...steps.map((step) => ({+ id: step.id,+ ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,+ })),+ ];++ const edges = [...childrenByStepId.entries()].flatMap(([source, targets]) =>+ targets.map((target) => ({ source, target })),+ );++ return computeWorkflowLayout({ nodes, edges }).map(+ ({ id, centerPosition }) => ({ id, position: centerPosition }),+ );+};diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.tsindex 34e51e7dc18..33b7084398b 100644--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts@@ -1,12 +1,7 @@import { Injectable } from '@nestjs/common';import { isDefined } from 'twenty-shared/utils';-import {- buildWorkflowGraph,- computeWorkflowLayout,- TRIGGER_STEP_ID,- WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,-} from 'twenty-shared/workflow';+import { TRIGGER_STEP_ID } from 'twenty-shared/workflow';import { WithLock } from 'src/engine/core-modules/cache-lock/with-lock.decorator';import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';@@ -30,6 +25,7 @@ import { assertWorkflowVersionHasSteps } from 'src/modules/workflow/common/utilsimport { assertWorkflowVersionIsDraft } from 'src/modules/workflow/common/utils/assert-workflow-version-is-draft.util';import { assertWorkflowVersionTriggerIsDefined } from 'src/modules/workflow/common/utils/assert-workflow-version-trigger-is-defined.util';import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';+import { computeWorkflowStepPositions } from 'src/modules/workflow/workflow-builder/utils/compute-workflow-step-positions.util';import { remapDuplicatedStepDestinations } from 'src/modules/workflow/workflow-builder/utils/remap-duplicated-step-destinations.util';import { WorkflowVersionStepOperationsWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service';import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.workspace-service';@@ -417,35 +413,12 @@ export class WorkflowVersionWorkspaceService {assertWorkflowVersionIsDraft(workflowVersion);- const steps = workflowVersion.steps ?? [];-- const { childrenByStepId } = buildWorkflowGraph({- trigger: workflowVersion.trigger,- steps,- });-- const nodes = [- {- id: TRIGGER_STEP_ID,- ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,- },- ...steps.map((step) => ({- id: step.id,- ...WORKFLOW_DIAGRAM_DEFAULT_NODE_DIMENSIONS,- })),- ];-- const edges = [...childrenByStepId.entries()].flatMap(([source, targets]) =>- targets.map((target) => ({ source, target })),- );-- const positions = computeWorkflowLayout({ nodes, edges }).map(- ({ id, centerPosition }) => ({ id, position: centerPosition }),- );-await this.updateWorkflowVersionPositions({workflowVersionId,- positions,+ positions: computeWorkflowStepPositions({+ trigger: workflowVersion.trigger,+ steps: workflowVersion.steps ?? [],+ }),workspaceId,});}diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant.tsnew file mode 100644index 00000000000..3e693ddf5f2--- /dev/null+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant.ts@@ -0,0 +1,8 @@+import { type ActorMetadata, FieldActorSource } from 'twenty-shared/types';++export const DEFAULT_AGENT_WORKFLOW_ACTOR: ActorMetadata = {+ source: FieldActorSource.AGENT,+ workspaceMemberId: null,+ name: 'Agent',+ context: {},+};diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.tsindex 86acdf15255..2a46b6aff2a 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/services/workflow-tool.workspace-service.ts@@ -1,21 +1,20 @@import { Injectable } from '@nestjs/common';import { type ToolSet } from 'ai';+import { type ActorMetadata } from 'twenty-shared/types';-import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';-import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';+import { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';+import { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';+import { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';+import { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';+import { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';+import { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';import { AgentService } from 'src/engine/metadata-modules/ai/ai-agent/agent.service';import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';import { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logic-function/services/logic-function-from-source.service';-import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';-import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { WorkflowSchemaWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service';-import { WorkflowVersionValidationWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.workspace-service';-import { WorkflowVersionEdgeWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service';-import { WorkflowVersionStepHelpersWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-helpers.workspace-service';-import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.workspace-service';-import { WorkflowVersionWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service';import { createActivateWorkflowVersionTool } from 'src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool';import { createComputeStepOutputSchemaTool } from 'src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool';import { createCreateCompleteWorkflowTool } from 'src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool';@@ -38,156 +37,86 @@ import { createUpdateWorkflowVersionPositionsTool } from 'src/modules/workflow/wimport { createUpdateWorkflowVersionStepTool } from 'src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool';import { createUpdateWorkflowVersionTriggerTool } from 'src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool';import { createValidateWorkflowTool } from 'src/modules/workflow/workflow-tools/tools/validate-workflow.tool';-import { type WorkflowToolDependencies } from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';-import { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service';+import {+ type WorkflowToolContext,+ type WorkflowToolDependencies,+} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';@Injectable()export class WorkflowToolWorkspaceService {private readonly deps: WorkflowToolDependencies;constructor(- workflowVersionStepService: WorkflowVersionStepWorkspaceService,- workflowVersionStepHelpersService: WorkflowVersionStepHelpersWorkspaceService,- workflowVersionEdgeService: WorkflowVersionEdgeWorkspaceService,- workflowVersionService: WorkflowVersionWorkspaceService,- workflowTriggerService: WorkflowTriggerWorkspaceService,+ coreWorkflowListService: CoreWorkflowListService,+ coreWorkflowVersionListService: CoreWorkflowVersionListService,+ coreWorkflowMutationService: CoreWorkflowMutationWorkspaceService,+ coreWorkflowVersionMutationService: CoreWorkflowVersionMutationWorkspaceService,+ coreWorkflowVersionWriteService: CoreWorkflowVersionWriteService,+ coreWorkflowLifecycleService: CoreWorkflowLifecycleWorkspaceService,workflowSchemaService: WorkflowSchemaWorkspaceService,- workflowVersionValidationWorkspaceService: WorkflowVersionValidationWorkspaceService,workspaceOrmManager: WorkspaceOrmManager,- recordPositionService: RecordPositionService,logicFunctionFromSourceService: LogicFunctionFromSourceService,flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,agentService: AgentService,- workflowCommonService: WorkflowCommonWorkspaceService,- workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,) {this.deps = {- workflowVersionStepService,- workflowVersionStepHelpersService,- workflowVersionEdgeService,- workflowVersionService,- workflowTriggerService,+ coreWorkflowListService,+ coreWorkflowVersionListService,+ coreWorkflowMutationService,+ coreWorkflowVersionMutationService,+ coreWorkflowVersionWriteService,+ coreWorkflowLifecycleService,workflowSchemaService,- workflowVersionValidationWorkspaceService,workspaceOrmManager,- recordPositionService,logicFunctionFromSourceService,flatEntityMapsCacheService,agentService,- workflowCommonService,- workflowVersionCoreSyncService,};}- generateWorkflowTools(- workspaceId: string,- rolePermissionConfig: RolePermissionConfig,- ): ToolSet {- const context = { workspaceId };- const contextWithPermissions = { workspaceId, rolePermissionConfig };+ generateWorkflowTools({+ workspaceId,+ rolePermissionConfig,+ actorContext,+ userWorkspaceId,+ }: {+ workspaceId: string;+ rolePermissionConfig: RolePermissionConfig;+ actorContext?: ActorMetadata;+ userWorkspaceId?: string;+ }): ToolSet {+ const context: WorkflowToolContext = {+ workspaceId,+ rolePermissionConfig,+ actorContext,+ userWorkspaceId,+ };- const createCompleteWorkflow = createCreateCompleteWorkflowTool(- this.deps,- contextWithPermissions,- );- const createWorkflowVersionStep = createCreateWorkflowVersionStepTool(- this.deps,- context,- );- const updateWorkflowVersionStep = createUpdateWorkflowVersionStepTool(- this.deps,- context,- );- const updateWorkflowVersionTrigger = createUpdateWorkflowVersionTriggerTool(- this.deps,- context,- );- const deleteWorkflowVersionStep = createDeleteWorkflowVersionStepTool(- this.deps,- context,- );- const createWorkflowVersionEdge = createCreateWorkflowVersionEdgeTool(- this.deps,- context,- );- const deleteWorkflowVersionEdge = createDeleteWorkflowVersionEdgeTool(- this.deps,- context,- );- const createDraftFromWorkflowVersion =- createCreateDraftFromWorkflowVersionTool(this.deps, context);- const updateWorkflowVersionPositions =- createUpdateWorkflowVersionPositionsTool(this.deps, context);- const activateWorkflowVersion = createActivateWorkflowVersionTool(- this.deps,- context,- );- const deactivateWorkflowVersion = createDeactivateWorkflowVersionTool(- this.deps,- context,- );- const computeStepOutputSchema = createComputeStepOutputSchemaTool(- this.deps,- context,- );- const getWorkflowCurrentVersion = createGetWorkflowCurrentVersionTool(- this.deps,- contextWithPermissions,- );- const getWorkflowRun = createGetWorkflowRunTool(- this.deps,- contextWithPermissions,- );- const listWorkflowRuns = createListWorkflowRunsTool(- this.deps,- contextWithPermissions,- );- const listWorkflows = createListWorkflowsTool(- this.deps,- contextWithPermissions,- );- const deleteWorkflow = createDeleteWorkflowTool(- this.deps,- contextWithPermissions,- );- const getLogicFunctionSource = createGetLogicFunctionSourceTool(- this.deps,- context,- );- const updateLogicFunctionSource = createUpdateLogicFunctionSourceTool(- this.deps,- context,- );- const listLogicFunctionTools = createListLogicFunctionToolsTool(- this.deps,- context,- );- const updateAgent = createUpdateAgentTool(this.deps, context);- const validateWorkflow = createValidateWorkflowTool(this.deps, context);+ const tools = [+ createCreateCompleteWorkflowTool(this.deps, context),+ createCreateWorkflowVersionStepTool(this.deps, context),+ createUpdateWorkflowVersionStepTool(this.deps, context),+ createUpdateWorkflowVersionTriggerTool(this.deps, context),+ createDeleteWorkflowVersionStepTool(this.deps, context),+ createCreateWorkflowVersionEdgeTool(this.deps, context),+ createDeleteWorkflowVersionEdgeTool(this.deps, context),+ createCreateDraftFromWorkflowVersionTool(this.deps, context),+ createUpdateWorkflowVersionPositionsTool(this.deps, context),+ createActivateWorkflowVersionTool(this.deps, context),+ createDeactivateWorkflowVersionTool(this.deps, context),+ createComputeStepOutputSchemaTool(this.deps, context),+ createGetWorkflowCurrentVersionTool(this.deps, context),+ createListWorkflowsTool(this.deps, context),+ createDeleteWorkflowTool(this.deps, context),+ createGetWorkflowRunTool(this.deps, context),+ createListWorkflowRunsTool(this.deps, context),+ createGetLogicFunctionSourceTool(this.deps, context),+ createUpdateLogicFunctionSourceTool(this.deps, context),+ createListLogicFunctionToolsTool(this.deps, context),+ createUpdateAgentTool(this.deps, context),+ createValidateWorkflowTool(this.deps, context),+ ];- return {- [createCompleteWorkflow.name]: createCompleteWorkflow,- [createWorkflowVersionStep.name]: createWorkflowVersionStep,- [updateWorkflowVersionStep.name]: updateWorkflowVersionStep,- [updateWorkflowVersionTrigger.name]: updateWorkflowVersionTrigger,- [deleteWorkflowVersionStep.name]: deleteWorkflowVersionStep,- [createWorkflowVersionEdge.name]: createWorkflowVersionEdge,- [deleteWorkflowVersionEdge.name]: deleteWorkflowVersionEdge,- [createDraftFromWorkflowVersion.name]: createDraftFromWorkflowVersion,- [updateWorkflowVersionPositions.name]: updateWorkflowVersionPositions,- [activateWorkflowVersion.name]: activateWorkflowVersion,- [deactivateWorkflowVersion.name]: deactivateWorkflowVersion,- [computeStepOutputSchema.name]: computeStepOutputSchema,- [getWorkflowCurrentVersion.name]: getWorkflowCurrentVersion,- [listWorkflows.name]: listWorkflows,- [deleteWorkflow.name]: deleteWorkflow,- [getWorkflowRun.name]: getWorkflowRun,- [listWorkflowRuns.name]: listWorkflowRuns,- [getLogicFunctionSource.name]: getLogicFunctionSource,- [updateLogicFunctionSource.name]: updateLogicFunctionSource,- [listLogicFunctionTools.name]: listLogicFunctionTools,- [updateAgent.name]: updateAgent,- [validateWorkflow.name]: validateWorkflow,- };+ return Object.fromEntries(tools.map((tool) => [tool.name, tool]));}}diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.tsindex 6afe8ba9862..3afea0ab37c 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/delete-workflow.tool.spec.ts@@ -1,70 +1,79 @@import { createDeleteWorkflowTool } from 'src/modules/workflow/workflow-tools/tools/delete-workflow.tool';-const WORKFLOW_ID = 'b3b8a4f0-0000-4000-8000-000000000000';+const CORE_WORKFLOW_ID = 'b3b8a4f0-0000-4000-8000-000000000000';const buildTool = () => {- const workflowRepository = {- softDelete: jest.fn().mockResolvedValue({ affected: 1 }),+ const coreWorkflowListService = {+ findOneById: jest.fn().mockResolvedValue({ id: CORE_WORKFLOW_ID }),};- const workspaceOrmManager = {- executeInWorkspaceContext: jest.fn((callback: () => unknown) => callback()),- getRepository: jest.fn().mockReturnValue(workflowRepository),- };- const workflowCommonService = {- handleWorkflowSubEntities: jest.fn().mockResolvedValue(undefined),+ const coreWorkflowMutationService = {+ deleteWorkflows: jest.fn().mockResolvedValue([]),};const tool = createDeleteWorkflowTool({- workspaceOrmManager,- workflowCommonService,+ coreWorkflowListService,+ coreWorkflowMutationService,} as never,{workspaceId: 'workspace-id',rolePermissionConfig: { shouldBypassPermissionChecks: true },- } as never,+ },);- return {- tool,- workflowRepository,- workspaceOrmManager,- workflowCommonService,- };+ return { tool, coreWorkflowListService, coreWorkflowMutationService };};-const baseInput = {- workflowId: WORKFLOW_ID,-} as unknown as Parameters<- ReturnType<typeof createDeleteWorkflowTool>['execute']->[0];+const baseInput = { coreWorkflowId: CORE_WORKFLOW_ID };describe('createDeleteWorkflowTool', () => {beforeEach(() => {jest.clearAllMocks();});- it('should soft delete the workflow and clean up sub-entities', async () => {- const { tool, workflowRepository, workflowCommonService } = buildTool();+ it('should delete the workflow through the core destroy path', async () => {+ const { tool, coreWorkflowMutationService } = buildTool();const result = (await tool.execute(baseInput)) as Record<string, unknown>;- expect(workflowRepository.softDelete).toHaveBeenCalledWith(WORKFLOW_ID);- expect(- workflowCommonService.handleWorkflowSubEntities,- ).toHaveBeenCalledWith({- workflowIds: [WORKFLOW_ID],+ expect(coreWorkflowMutationService.deleteWorkflows).toHaveBeenCalledWith({workspaceId: 'workspace-id',- operation: 'delete',+ userWorkspaceId: undefined,+ coreWorkflowIds: [CORE_WORKFLOW_ID],});expect(result.success).toBe(true);- expect(result.workflowId).toBe(WORKFLOW_ID);+ expect(result.coreWorkflowId).toBe(CORE_WORKFLOW_ID);+ });++ it('should delete a workflow that has no workspace mirror', async () => {+ const { tool, coreWorkflowMutationService } = buildTool();++ coreWorkflowMutationService.deleteWorkflows.mockResolvedValue([]);++ const result = (await tool.execute(baseInput)) as Record<string, unknown>;++ expect(result.success).toBe(true);+ });++ it('should report not found without deleting when the core workflow is absent', async () => {+ const { tool, coreWorkflowListService, coreWorkflowMutationService } =+ buildTool();++ coreWorkflowListService.findOneById.mockResolvedValue(null);++ const result = (await tool.execute(baseInput)) as Record<string, unknown>;++ expect(coreWorkflowMutationService.deleteWorkflows).not.toHaveBeenCalled();+ expect(result.success).toBe(false);+ expect(result.error).toBe('Workflow not found');});it('should return a failure result when deletion throws', async () => {- const { tool, workflowRepository } = buildTool();+ const { tool, coreWorkflowMutationService } = buildTool();- workflowRepository.softDelete.mockRejectedValue(new Error('boom'));+ coreWorkflowMutationService.deleteWorkflows.mockRejectedValue(+ new Error('boom'),+ );const result = (await tool.execute(baseInput)) as Record<string, unknown>;diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.tsindex 159d640b666..bd58bf66b31 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-current-version.tool.spec.ts@@ -1,11 +1,13 @@-import { WorkflowVersionStatus } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';+import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';import { type WorkflowToolDependencies } from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';import { createGetWorkflowCurrentVersionTool } from '../get-workflow-current-version.tool';const WORKSPACE_ID = '20202020-aaaa-4d02-bf25-6aeccf7ea419';-const WORKFLOW_ID = '20202020-bbbb-4d02-bf25-6aeccf7ea419';+const CORE_WORKFLOW_ID = '20202020-bbbb-4d02-bf25-6aeccf7ea419';const ROLE_ID = '20202020-cccc-4d02-bf25-6aeccf7ea419';+const CORE_DRAFT_VERSION_ID = '20202020-dddd-4d02-bf25-6aeccf7ea419';+const CORE_ACTIVE_VERSION_ID = '20202020-eeee-4d02-bf25-6aeccf7ea419';const buildContext = () => ({workspaceId: WORKSPACE_ID,@@ -13,95 +15,82 @@ const buildContext = () => ({});const buildDeps = ({- workflow,- versions,+ coreWorkflow,+ coreWorkflowVersions,}: {- workflow: unknown;- versions: unknown[];-}) => {- const getRepositoryMock = jest.fn();-- getRepositoryMock.mockReturnValueOnce({- findOne: jest.fn().mockResolvedValue(workflow),- });-- getRepositoryMock.mockReturnValueOnce({- find: jest.fn().mockResolvedValue(versions),- });+ coreWorkflow: unknown;+ coreWorkflowVersions: { id: string; status: CoreWorkflowVersionStatus }[];+}) => ({+ coreWorkflowListService: {+ findOneById: jest.fn().mockResolvedValue(coreWorkflow),+ },+ coreWorkflowVersionListService: {+ findManyByCoreWorkflowId: jest.fn().mockResolvedValue(coreWorkflowVersions),+ findOneByCoreWorkflowVersionId: jest+ .fn()+ .mockImplementation(async ({ coreWorkflowVersionId }) => ({+ id: coreWorkflowVersionId,+ label: 'v1',+ status: CoreWorkflowVersionStatus.DRAFT,+ trigger: null,+ steps: [],+ })),+ },+});- return {- workspaceOrmManager: {- executeInWorkspaceContext: jest- .fn()- .mockImplementation(async (fn) => fn()),- getRepository: getRepositoryMock,- },- };-};+const buildTool = (deps: ReturnType<typeof buildDeps>) =>+ createGetWorkflowCurrentVersionTool(+ deps as unknown as Pick<+ WorkflowToolDependencies,+ 'coreWorkflowListService' | 'coreWorkflowVersionListService'+ >,+ buildContext(),+ );describe('get_workflow_current_version tool', () => {- it('should pass rolePermissionConfig to both getRepository calls', async () => {- const context = buildContext();+ it('should read the definition from core using the core workflow id', async () => {const deps = buildDeps({- workflow: { id: WORKFLOW_ID },- versions: [+ coreWorkflow: { id: CORE_WORKFLOW_ID },+ coreWorkflowVersions: [{- id: 'v1',- status: WorkflowVersionStatus.DRAFT,- workflowId: WORKFLOW_ID,+ id: CORE_DRAFT_VERSION_ID,+ status: CoreWorkflowVersionStatus.DRAFT,},],});- const tool = createGetWorkflowCurrentVersionTool(- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context,- );-- await tool.execute({ workflowId: WORKFLOW_ID });+ await buildTool(deps).execute({ coreWorkflowId: CORE_WORKFLOW_ID });- expect(deps.workspaceOrmManager.getRepository).toHaveBeenNthCalledWith(- 1,- 'workflow',- context.rolePermissionConfig,- );- expect(deps.workspaceOrmManager.getRepository).toHaveBeenNthCalledWith(- 2,- 'workflowVersion',- context.rolePermissionConfig,- );+ expect(deps.coreWorkflowListService.findOneById).toHaveBeenCalledWith({+ workspaceId: WORKSPACE_ID,+ coreWorkflowId: CORE_WORKFLOW_ID,+ });+ expect(+ deps.coreWorkflowVersionListService.findManyByCoreWorkflowId,+ ).toHaveBeenCalledWith({+ workspaceId: WORKSPACE_ID,+ coreWorkflowId: CORE_WORKFLOW_ID,+ });});it('should return draft version over active version', async () => {- const context = buildContext();const deps = buildDeps({- workflow: { id: WORKFLOW_ID },- versions: [+ coreWorkflow: { id: CORE_WORKFLOW_ID },+ coreWorkflowVersions: [{- id: 'v-active',- name: 'Active',- status: WorkflowVersionStatus.ACTIVE,- workflowId: WORKFLOW_ID,- trigger: null,- steps: [],+ id: CORE_ACTIVE_VERSION_ID,+ status: CoreWorkflowVersionStatus.ACTIVE,},{- id: 'v-draft',- name: 'Draft',- status: WorkflowVersionStatus.DRAFT,- workflowId: WORKFLOW_ID,- trigger: null,- steps: [],+ id: CORE_DRAFT_VERSION_ID,+ status: CoreWorkflowVersionStatus.DRAFT,},],});- const tool = createGetWorkflowCurrentVersionTool(- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context,- );-- const result = await tool.execute({ workflowId: WORKFLOW_ID });+ const result = await buildTool(deps).execute({+ coreWorkflowId: CORE_WORKFLOW_ID,+ });expect(result.success).toBe(true);@@ -112,36 +101,34 @@ describe('get_workflow_current_version tool', () => {throw new Error('Expected workflowVersion to be present in the result');}- expect(result.workflowVersion.id).toBe('v-draft');+ expect(result.workflowVersion.coreWorkflowVersionId).toBe(+ CORE_DRAFT_VERSION_ID,+ );+ expect(result.workflowVersion.coreWorkflowId).toBe(CORE_WORKFLOW_ID);});it('should return error when workflow is not found', async () => {- const context = buildContext();- const deps = buildDeps({ workflow: null, versions: [] });+ const deps = buildDeps({ coreWorkflow: null, coreWorkflowVersions: [] });- const tool = createGetWorkflowCurrentVersionTool(- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context,- );-- const result = await tool.execute({ workflowId: WORKFLOW_ID });+ const result = await buildTool(deps).execute({+ coreWorkflowId: CORE_WORKFLOW_ID,+ });expect(result.success).toBe(false);- expect(result.error).toContain(WORKFLOW_ID);+ expect(result.error).toContain(CORE_WORKFLOW_ID);});- it('should return error when no draft or active version exists', async () => {- const context = buildContext();- const deps = buildDeps({ workflow: { id: WORKFLOW_ID }, versions: [] });-- const tool = createGetWorkflowCurrentVersionTool(- deps as unknown as Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context,- );+ it('should return error when no draft, active or deactivated version exists', async () => {+ const deps = buildDeps({+ coreWorkflow: { id: CORE_WORKFLOW_ID },+ coreWorkflowVersions: [],+ });- const result = await tool.execute({ workflowId: WORKFLOW_ID });+ const result = await buildTool(deps).execute({+ coreWorkflowId: CORE_WORKFLOW_ID,+ });expect(result.success).toBe(false);- expect(result.error).toContain('no draft or active version');+ expect(result.error).toContain('no draft, active or deactivated version');});});diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.tsindex a41ae152f43..43acf56fd01 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/get-workflow-run.tool.spec.ts@@ -48,8 +48,8 @@ describe('get_workflow_run tool', () => {startedAt: '2025-01-01T00:00:00Z',endedAt: '2025-01-01T00:01:00Z',enqueuedAt: null,- workflowId: 'wf-1',- workflowVersionId: 'wfv-1',+ coreWorkflowId: 'core-wf-1',+ coreWorkflowVersionId: 'core-wfv-1',state: {workflowRunError: 'Something went wrong',flow: {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.tsindex bc82e7c45ca..429377f8636 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/list-workflow-runs.tool.spec.ts@@ -47,8 +47,8 @@ describe('list_workflow_runs tool', () => {state: {},startedAt: '2025-01-01T00:00:00Z',endedAt: '2025-01-01T00:01:00Z',- workflowId: 'wf-1',- workflowVersionId: 'wfv-1',+ coreWorkflowId: 'core-wf-1',+ coreWorkflowVersionId: 'core-wfv-1',},{id: 'run-2',@@ -57,8 +57,8 @@ describe('list_workflow_runs tool', () => {state: { workflowRunError: 'Timeout' },startedAt: '2025-01-02T00:00:00Z',endedAt: '2025-01-02T00:01:00Z',- workflowId: 'wf-1',- workflowVersionId: 'wfv-1',+ coreWorkflowId: 'core-wf-1',+ coreWorkflowVersionId: 'core-wfv-1',},];@@ -80,6 +80,8 @@ describe('list_workflow_runs tool', () => {expect(result.workflowRuns).toHaveLength(2);expect(result.workflowRuns[0].id).toBe('run-1');+ expect(result.workflowRuns[0].coreWorkflowId).toBe('core-wf-1');+ expect(result.workflowRuns[0].coreWorkflowVersionId).toBe('core-wfv-1');expect(result.workflowRuns[1].error).toBe('Timeout');});@@ -101,13 +103,13 @@ describe('list_workflow_runs tool', () => {);await tool.execute({- workflowId: 'wf-1',+ coreWorkflowId: 'core-wf-1',status: WorkflowRunStatus.FAILED,limit: 5,});expect(findMock).toHaveBeenCalledWith({- where: { workflowId: 'wf-1', status: WorkflowRunStatus.FAILED },+ where: { coreWorkflowId: 'core-wf-1', status: WorkflowRunStatus.FAILED },order: { createdAt: 'DESC' },take: 5,});diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.tsindex 7fda9353ed3..5902ece8377 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-agent.tool.spec.ts@@ -12,21 +12,20 @@ const buildAiAgentStep = (agentId: string, stepId = 'step-1') => ({});const buildTool = ({- draftVersions = [],+ draftCoreVersions = [],}: {- draftVersions?: { id: string; status: string; steps: unknown[] | null }[];+ draftCoreVersions?: { id: string; steps: unknown[] | null }[];} = {}) => {const agentService = {updateOneAgent: jest.fn().mockResolvedValue({ id: AGENT_ID }),};- const workflowVersionStepService = {- updateWorkflowVersionStep: jest.fn().mockResolvedValue(undefined),+ const coreWorkflowVersionMutationService = {+ updateStep: jest.fn().mockResolvedValue(undefined),};- const workflowVersionRepository = {- find: jest.fn().mockResolvedValue(draftVersions),- };- const workspaceOrmManager = {- getRepository: jest.fn().mockReturnValue(workflowVersionRepository),+ const coreWorkflowVersionListService = {+ findDraftCoreWorkflowVersions: jest+ .fn()+ .mockResolvedValue(draftCoreVersions),};const flatEntityMapsCacheService = {invalidateFlatEntityMaps: jest.fn().mockResolvedValue(undefined),@@ -35,18 +34,21 @@ const buildTool = ({const tool = createUpdateAgentTool({agentService,- workflowVersionStepService,- workspaceOrmManager,+ coreWorkflowVersionMutationService,+ coreWorkflowVersionListService,flatEntityMapsCacheService,} as never,- { workspaceId: WORKSPACE_ID },+ {+ workspaceId: WORKSPACE_ID,+ rolePermissionConfig: { shouldBypassPermissionChecks: true },+ },);return {tool,agentService,- workflowVersionStepService,- workspaceOrmManager,+ coreWorkflowVersionMutationService,+ coreWorkflowVersionListService,flatEntityMapsCacheService,};};@@ -58,10 +60,13 @@ describe('createUpdateAgentTool', () => {it('should resync the linked AI_AGENT step output schema when responseFormat changes', async () => {const step = buildAiAgentStep(AGENT_ID);- const { tool, workflowVersionStepService, flatEntityMapsCacheService } =- buildTool({- draftVersions: [{ id: 'version-1', status: 'DRAFT', steps: [step] }],- });+ const {+ tool,+ coreWorkflowVersionMutationService,+ flatEntityMapsCacheService,+ } = buildTool({+ draftCoreVersions: [{ id: 'core-version-1', steps: [step] }],+ });const result = (await tool.execute({agentId: AGENT_ID,@@ -81,22 +86,22 @@ describe('createUpdateAgentTool', () => {workspaceId: WORKSPACE_ID,flatMapsKeys: ['flatAgentMaps'],});- expect(- workflowVersionStepService.updateWorkflowVersionStep,- ).toHaveBeenCalledWith({+ expect(coreWorkflowVersionMutationService.updateStep).toHaveBeenCalledWith({workspaceId: WORKSPACE_ID,- workflowVersionId: 'version-1',+ coreWorkflowVersionId: 'core-version-1',step,});});it('should not resync when responseFormat is not provided', async () => {const step = buildAiAgentStep(AGENT_ID);- const { tool, workflowVersionStepService, workspaceOrmManager } = buildTool(- {- draftVersions: [{ id: 'version-1', status: 'DRAFT', steps: [step] }],- },- );+ const {+ tool,+ coreWorkflowVersionMutationService,+ coreWorkflowVersionListService,+ } = buildTool({+ draftCoreVersions: [{ id: 'core-version-1', steps: [step] }],+ });const result = (await tool.execute({agentId: AGENT_ID,@@ -104,18 +109,19 @@ describe('createUpdateAgentTool', () => {} as never)) as Record<string, unknown>;expect(result.success).toBe(true);- expect(workspaceOrmManager.getRepository).not.toHaveBeenCalled();expect(- workflowVersionStepService.updateWorkflowVersionStep,+ coreWorkflowVersionListService.findDraftCoreWorkflowVersions,+ ).not.toHaveBeenCalled();+ expect(+ coreWorkflowVersionMutationService.updateStep,).not.toHaveBeenCalled();});it('should skip steps referencing a different agent', async () => {- const { tool, workflowVersionStepService } = buildTool({- draftVersions: [+ const { tool, coreWorkflowVersionMutationService } = buildTool({+ draftCoreVersions: [{- id: 'version-1',- status: 'DRAFT',+ id: 'core-version-1',steps: [buildAiAgentStep('another-agent-id')],},],@@ -127,17 +133,17 @@ describe('createUpdateAgentTool', () => {} as never);expect(- workflowVersionStepService.updateWorkflowVersionStep,+ coreWorkflowVersionMutationService.updateStep,).not.toHaveBeenCalled();});it('should still report agent update success when the resync fails', async () => {const step = buildAiAgentStep(AGENT_ID);- const { tool, workflowVersionStepService } = buildTool({- draftVersions: [{ id: 'version-1', status: 'DRAFT', steps: [step] }],+ const { tool, coreWorkflowVersionMutationService } = buildTool({+ draftCoreVersions: [{ id: 'core-version-1', steps: [step] }],});- workflowVersionStepService.updateWorkflowVersionStep.mockRejectedValue(+ coreWorkflowVersionMutationService.updateStep.mockRejectedValue(new Error('boom'),);diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.tsindex 5abe4929f99..bb2c4aae5d6 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/__tests__/update-workflow-version-step.tool.spec.ts@@ -1,5 +1,7 @@import { createUpdateWorkflowVersionStepTool } from 'src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool';+const CORE_WORKFLOW_VERSION_ID = 'b3b8a4f0-0000-4000-8000-000000000000';+const mockStep = {id: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',name: 'Send email',@@ -9,20 +11,23 @@ const mockStep = {};const buildTool = () => {- const workflowVersionStepService = {- updateWorkflowVersionStep: jest.fn().mockResolvedValue(mockStep),+ const coreWorkflowVersionMutationService = {+ updateStep: jest.fn().mockResolvedValue(mockStep),};const tool = createUpdateWorkflowVersionStepTool(- { workflowVersionStepService } as never,- { workspaceId: 'workspace-id' },+ { coreWorkflowVersionMutationService } as never,+ {+ workspaceId: 'workspace-id',+ rolePermissionConfig: { shouldBypassPermissionChecks: true },+ },);- return { tool, workflowVersionStepService };+ return { tool, coreWorkflowVersionMutationService };};const baseInput = {- workflowVersionId: 'b3b8a4f0-0000-4000-8000-000000000000',+ coreWorkflowVersionId: CORE_WORKFLOW_VERSION_ID,step: mockStep,} as unknown as Parameters<ReturnType<typeof createUpdateWorkflowVersionStepTool>['execute']@@ -33,25 +38,23 @@ describe('createUpdateWorkflowVersionStepTool', () => {jest.clearAllMocks();});- it('updates the step and returns the result', async () => {- const { tool, workflowVersionStepService } = buildTool();+ it('updates the step on the core version and returns the result', async () => {+ const { tool, coreWorkflowVersionMutationService } = buildTool();const result = await tool.execute(baseInput);- expect(- workflowVersionStepService.updateWorkflowVersionStep,- ).toHaveBeenCalledWith({+ expect(coreWorkflowVersionMutationService.updateStep).toHaveBeenCalledWith({workspaceId: 'workspace-id',- workflowVersionId: baseInput.workflowVersionId,+ coreWorkflowVersionId: CORE_WORKFLOW_VERSION_ID,step: mockStep,});expect(result).toEqual(mockStep);});it('returns a failure when the update throws', async () => {- const { tool, workflowVersionStepService } = buildTool();+ const { tool, coreWorkflowVersionMutationService } = buildTool();- workflowVersionStepService.updateWorkflowVersionStep.mockRejectedValue(+ coreWorkflowVersionMutationService.updateStep.mockRejectedValue(new Error('boom'),);diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.tsindex 2c8af2d27b9..e5620c6c29a 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/activate-workflow-version.tool.ts@@ -6,10 +6,10 @@ import {} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const activateWorkflowVersionSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version to activate'),+ .describe('The core workflow version UUID to activate'),});type ActivateWorkflowVersionInput = z.infer<@@ -17,7 +17,7 @@ type ActivateWorkflowVersionInput = z.infer<>;export const createActivateWorkflowVersionTool = (- deps: Pick<WorkflowToolDependencies, 'workflowTriggerService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowLifecycleService'>,context: WorkflowToolContext,) => ({name: 'activate_workflow_version' as const,@@ -26,9 +26,12 @@ export const createActivateWorkflowVersionTool = (inputSchema: activateWorkflowVersionSchema,execute: async (parameters: ActivateWorkflowVersionInput) => {try {- return await deps.workflowTriggerService.activateWorkflowVersion(- parameters.workflowVersionId,- context.workspaceId,+ return await deps.coreWorkflowLifecycleService.activateCoreWorkflowVersion(+ {+ workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,+ },);} catch (error) {return {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.tsindex 0ba3fae9385..4308c1318d7 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/compute-step-output-schema.tool.ts@@ -1,3 +1,4 @@+import { isDefined } from 'twenty-shared/utils';import {workflowActionSchema,workflowTriggerSchema,@@ -15,16 +16,16 @@ const computeStepOutputSchemaSchema = z.object({step: z.union([workflowTriggerSchema, workflowActionSchema]).describe('The workflow step configuration'),- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version'),+ .describe('The core workflow version UUID'),});export const createComputeStepOutputSchemaTool = (deps: Pick<WorkflowToolDependencies,- 'workflowSchemaService' | 'workflowCommonService'+ 'workflowSchemaService' | 'coreWorkflowVersionListService'>,context: WorkflowToolContext,) => ({@@ -34,21 +35,31 @@ export const createComputeStepOutputSchemaTool = (inputSchema: computeStepOutputSchemaSchema,execute: async (parameters: {step: WorkflowTrigger | WorkflowAction;- workflowVersionId: string;+ coreWorkflowVersionId: string;}) => {try {- const workflowVersion =- await deps.workflowCommonService.getWorkflowVersionOrFail({- workflowVersionId: parameters.workflowVersionId,- workspaceId: context.workspaceId,- });+ const coreWorkflowVersion =+ await deps.coreWorkflowVersionListService.findOneByCoreWorkflowVersionId(+ {+ workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,+ },+ );++ if (!isDefined(coreWorkflowVersion)) {+ return {+ success: false,+ error: `Workflow version ${parameters.coreWorkflowVersionId} not found`,+ };+ }return await deps.workflowSchemaService.computeStepOutputSchema({step: parameters.step,workspaceId: context.workspaceId,workflowVersionContent: {- trigger: workflowVersion.trigger,- steps: workflowVersion.steps,+ trigger: coreWorkflowVersion.trigger,+ steps: coreWorkflowVersion.steps,},});} catch (error) {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.tsindex 04c4bb52715..16c262a38b9 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-complete-workflow.tool.ts@@ -1,20 +1,18 @@+import { isDefined } from 'twenty-shared/utils';import {workflowActionSchema,WorkflowActionType,workflowTriggerSchema,} from 'twenty-shared/workflow';-import { v4 as uuidv4 } from 'uuid';import { z } from 'zod';-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';+import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';import {WorkflowVersionStepException,WorkflowVersionStepExceptionCode,} from 'src/modules/workflow/common/exceptions/workflow-version-step.exception';-import { WorkflowVersionStatus } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';-import { WorkflowStatus } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';+import { DEFAULT_AGENT_WORKFLOW_ACTOR } from 'src/modules/workflow/workflow-tools/constants/default-agent-workflow-actor.constant';import { workflowStepConnectionOptionsSchema } from 'src/modules/workflow/workflow-tools/tools/schemas/workflow-step-connection-options.schema';import {type WorkflowToolContext,@@ -54,21 +52,16 @@ const createCompleteWorkflowSchema = z.object({type CreateCompleteWorkflowToolDeps = Pick<WorkflowToolDependencies,- | 'workflowVersionService'- | 'workflowVersionEdgeService'- | 'workflowTriggerService'- | 'workspaceOrmManager'- | 'recordPositionService'- | 'workflowVersionCoreSyncService'+ | 'coreWorkflowMutationService'+ | 'coreWorkflowVersionListService'+ | 'coreWorkflowVersionMutationService'+ | 'coreWorkflowVersionWriteService'+ | 'coreWorkflowLifecycleService'>;-type CreateCompleteWorkflowToolContext = WorkflowToolContext & {- rolePermissionConfig: RolePermissionConfig;-};-export const createCreateCompleteWorkflowTool = (deps: CreateCompleteWorkflowToolDeps,- context: CreateCompleteWorkflowToolContext,+ context: WorkflowToolContext,) => ({name: 'create_complete_workflow' as const,description: `Create a complete workflow with trigger, steps, and connections in a single operation.@@ -105,6 +98,8 @@ IMPORTANT: The tool schema provides comprehensive field descriptions, examples,This is the most efficient way for AI to create workflows as it handles all the complexity in one call.+Returns the core workflow ID and core workflow version ID, which every other workflow tool expects.+Call validate_workflow once when the workflow is complete, before activating.`,inputSchema: createCompleteWorkflowSchema,execute: async (parameters: {@@ -122,69 +117,66 @@ Call validate_workflow once when the workflow is complete, before activating.`,activate?: boolean;}) => {try {- const codeSteps = parameters.steps.filter(- (step) => step.type === ('CODE' as string),- );+ const { workspaceId } = context;- if (codeSteps.length > 0) {- throw new WorkflowVersionStepException(- 'CODE steps cannot be created via create_complete_workflow because it does not create the underlying logic function. Use create_workflow_version_step instead.',- WorkflowVersionStepExceptionCode.INVALID_REQUEST,- );- }+ assertStepTypesAreSupported(parameters.steps);- const aiAgentSteps = parameters.steps.filter(- (step) => step.type === WorkflowActionType.AI_AGENT,- );+ const coreWorkflow =+ await deps.coreWorkflowMutationService.createWorkflow({+ workspaceId,+ createdBy: context.actorContext ?? DEFAULT_AGENT_WORKFLOW_ACTOR,+ userWorkspaceId: undefined,+ name: parameters.name,+ });- if (aiAgentSteps.length > 0) {- throw new WorkflowVersionStepException(- 'AI_AGENT steps cannot be created via create_complete_workflow because it does not create the underlying agent. Use create_workflow_version_step instead, then call update_agent to configure the agent.',- WorkflowVersionStepExceptionCode.INVALID_REQUEST,- );- }- const workflowId = await createWorkflow({+ const coreWorkflowVersionId = await findInitialDraftCoreVersionIdOrThrow({deps,- context,- name: parameters.name,+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowId: coreWorkflow.id,});- const workflowVersionId = await createWorkflowVersion({- deps,- context,- workflowId,+ const { coreWorkflowVersion } =+ await deps.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion(+ {+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId,+ },+ );++ await deps.coreWorkflowVersionWriteService.writeContentAndMirror({+ workspaceId,+ coreWorkflowVersionId,+ expectedVersion: coreWorkflowVersion,trigger: parameters.trigger,steps: parameters.steps,});- if (parameters.edges && parameters.edges.length > 0) {- for (const edge of parameters.edges) {- await deps.workflowVersionEdgeService.createWorkflowVersionEdge({- source: edge.source === 'trigger' ? 'trigger' : edge.source,- target: edge.target,- sourceConnectionOptions: edge.sourceConnectionOptions,- workflowVersionId,- workspaceId: context.workspaceId,- });- }+ for (const edge of parameters.edges ?? []) {+ await deps.coreWorkflowVersionMutationService.createEdge({+ userWorkspaceId: context.userWorkspaceId,+ source: edge.source,+ target: edge.target,+ sourceConnectionOptions: edge.sourceConnectionOptions,+ coreWorkflowVersionId,+ workspaceId,+ });}- await deps.workflowVersionService.autoLayoutWorkflowVersion({- workflowVersionId,- workspaceId: context.workspaceId,- });+ await deps.coreWorkflowVersionMutationService.autoLayoutCoreWorkflowVersion(+ {+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId,+ },+ );if (parameters.activate) {- await deps.workflowTriggerService.activateWorkflowVersion(- workflowVersionId,- context.workspaceId,- );-- await updateWorkflowStatus({- deps,- context,- workflowId,- workflowVersionId,+ await deps.coreWorkflowLifecycleService.activateCoreWorkflowVersion({+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId,});}@@ -192,18 +184,20 @@ Call validate_workflow once when the workflow is complete, before activating.`,success: true,message: `Workflow "${parameters.name}" created successfully with ${parameters.steps.length} steps`,result: {- workflowId,- workflowVersionId,+ coreWorkflowId: coreWorkflow.id,+ coreWorkflowVersionId,name: parameters.name,stepIds: parameters.steps.map((step) => step.id),},- recordReferences: [- {- objectNameSingular: 'workflow',- recordId: workflowId,- displayName: parameters.name,- },- ],+ recordReferences: isDefined(coreWorkflow.workspaceWorkflowId)+ ? [+ {+ objectNameSingular: 'workflow',+ recordId: coreWorkflow.workspaceWorkflowId,+ displayName: parameters.name,+ },+ ]+ : [],};} catch (error) {return {@@ -215,113 +209,50 @@ Call validate_workflow once when the workflow is complete, before activating.`,},});-const createWorkflow = async ({- deps,- context,- name,-}: {- deps: CreateCompleteWorkflowToolDeps;- context: CreateCompleteWorkflowToolContext;- name: string;-}): Promise<string> => {- const authContext = buildSystemAuthContext(context.workspaceId);-- return deps.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workflowRepository = deps.workspaceOrmManager.getRepository(- 'workflow',- context.rolePermissionConfig,+const assertStepTypesAreSupported = (steps: WorkflowAction[]): void => {+ if (steps.some((step) => step.type === WorkflowActionType.CODE)) {+ throw new WorkflowVersionStepException(+ 'CODE steps cannot be created via create_complete_workflow because it does not create the underlying logic function. Use create_workflow_version_step instead.',+ WorkflowVersionStepExceptionCode.INVALID_REQUEST,);+ }- const workflowPosition =- await deps.recordPositionService.buildRecordPosition({- value: 'first',- objectMetadata: {- isCustom: false,- nameSingular: 'workflow',- },- workspaceId: context.workspaceId,- });-- const workflow = {- id: uuidv4(),- name,- statuses: [WorkflowStatus.DRAFT],- position: workflowPosition,- };-- await workflowRepository.insert(workflow);-- return workflow.id;- }, authContext);+ if (steps.some((step) => step.type === WorkflowActionType.AI_AGENT)) {+ throw new WorkflowVersionStepException(+ 'AI_AGENT steps cannot be created via create_complete_workflow because it does not create the underlying agent. Use create_workflow_version_step instead, then call update_agent to configure the agent.',+ WorkflowVersionStepExceptionCode.INVALID_REQUEST,+ );+ }};-const createWorkflowVersion = async ({+const findInitialDraftCoreVersionIdOrThrow = async ({deps,- context,- workflowId,- trigger,- steps,+ workspaceId,+ userWorkspaceId,+ coreWorkflowId,}: {deps: CreateCompleteWorkflowToolDeps;- context: CreateCompleteWorkflowToolContext;- workflowId: string;- trigger: WorkflowTrigger;- steps: WorkflowAction[];+ workspaceId: string;+ userWorkspaceId: string | undefined;+ coreWorkflowId: string;}): Promise<string> => {- const workflowVersionId = uuidv4();-- await deps.workflowVersionCoreSyncService.writeWorkflowVersionAndMirror(- context.workspaceId,- async (workflowVersionRepository) => {- const versionPosition =- await deps.recordPositionService.buildRecordPosition({- value: 'first',- objectMetadata: {- isCustom: false,- nameSingular: 'workflowVersion',- },- workspaceId: context.workspaceId,- });-- await workflowVersionRepository.insert({- id: workflowVersionId,- workflowId,- name: 'v1',- status: WorkflowVersionStatus.DRAFT,- trigger,- steps,- position: versionPosition,- });+ const coreWorkflowVersions =+ await deps.coreWorkflowVersionListService.findManyByCoreWorkflowId({+ workspaceId,+ userWorkspaceId,+ coreWorkflowId,+ });- return workflowVersionId;- },+ const draftVersion = coreWorkflowVersions.find(+ (version) => version.status === CoreWorkflowVersionStatus.DRAFT,);- return workflowVersionId;-};--const updateWorkflowStatus = async ({- deps,- context,- workflowId,- workflowVersionId,-}: {- deps: CreateCompleteWorkflowToolDeps;- context: CreateCompleteWorkflowToolContext;- workflowId: string;- workflowVersionId: string;-}) => {- const authContext = buildSystemAuthContext(context.workspaceId);-- await deps.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workflowRepository = deps.workspaceOrmManager.getRepository(- 'workflow',- context.rolePermissionConfig,+ if (!isDefined(draftVersion)) {+ throw new WorkflowVersionStepException(+ `Created workflow '${coreWorkflowId}' has no initial draft version`,+ WorkflowVersionStepExceptionCode.NOT_FOUND,);+ }- await workflowRepository.update(workflowId, {- statuses: [WorkflowStatus.ACTIVE],- lastPublishedVersionId: workflowVersionId,- });- }, authContext);+ return draftVersion.id;};diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.tsindex 642df1d192b..08b76221012 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-draft-from-workflow-version.tool.ts@@ -6,11 +6,11 @@ import {} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const createDraftFromWorkflowVersionSchema = z.object({- workflowId: z.string().uuid().describe('The UUID of the workflow'),- workflowVersionIdToCopy: z+ coreWorkflowId: z.string().uuid().describe('The core workflow UUID'),+ coreWorkflowVersionIdToCopy: z.string().uuid()- .describe('The UUID of the workflow version to create a draft from'),+ .describe('The core workflow version UUID to create a draft from'),});type CreateDraftFromWorkflowVersionInput = z.infer<@@ -18,20 +18,32 @@ type CreateDraftFromWorkflowVersionInput = z.infer<>;export const createCreateDraftFromWorkflowVersionTool = (- deps: Pick<WorkflowToolDependencies, 'workflowVersionService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,context: WorkflowToolContext,) => ({name: 'create_draft_from_workflow_version' as const,description:- 'Create a new draft workflow version from an existing one. This allows for iterative workflow development.',+ 'Create a new draft workflow version from an existing one. This allows for iterative workflow development. Returns the new core workflow version.',inputSchema: createDraftFromWorkflowVersionSchema,execute: async (parameters: CreateDraftFromWorkflowVersionInput) => {try {- return await deps.workflowVersionService.createDraftFromWorkflowVersion({- workspaceId: context.workspaceId,- workflowId: parameters.workflowId,- workflowVersionIdToCopy: parameters.workflowVersionIdToCopy,- });+ const coreWorkflowVersion =+ await deps.coreWorkflowVersionMutationService.createDraftFromCoreWorkflowVersion(+ {+ workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowId: parameters.coreWorkflowId,+ coreWorkflowVersionIdToCopy: parameters.coreWorkflowVersionIdToCopy,+ },+ );++ return {+ success: true,+ coreWorkflowVersionId: coreWorkflowVersion.id,+ coreWorkflowId: parameters.coreWorkflowId,+ status: coreWorkflowVersion.status,+ name: coreWorkflowVersion.label,+ };} catch (error) {return {success: false,diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.tsindex 227296ad1bd..8c201fdbfcf 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-edge.tool.ts@@ -7,10 +7,10 @@ import {} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const createWorkflowVersionEdgeSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version'),+ .describe('The core workflow version UUID'),source: z.union([z.literal('trigger'), z.string().uuid()]).describe('The source step: "trigger" or a step UUID'),@@ -23,7 +23,7 @@ type CreateWorkflowVersionEdgeInput = z.infer<>;export const createCreateWorkflowVersionEdgeTool = (- deps: Pick<WorkflowToolDependencies, 'workflowVersionEdgeService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,context: WorkflowToolContext,) => ({name: 'create_workflow_version_edge' as const,@@ -32,11 +32,12 @@ export const createCreateWorkflowVersionEdgeTool = (inputSchema: createWorkflowVersionEdgeSchema,execute: async (parameters: CreateWorkflowVersionEdgeInput) => {try {- return await deps.workflowVersionEdgeService.createWorkflowVersionEdge({+ return await deps.coreWorkflowVersionMutationService.createEdge({source: parameters.source,target: parameters.target,- workflowVersionId: parameters.workflowVersionId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,sourceConnectionOptions: parameters.sourceConnectionOptions,});} catch (error) {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.tsindex c5c94697ee7..85451ca024a 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/create-workflow-version-step.tool.ts@@ -2,7 +2,7 @@ import { isDefined } from 'twenty-shared/utils';import { TRIGGER_STEP_ID, WorkflowActionType } from 'twenty-shared/workflow';import { z } from 'zod';-import type { CreateWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/create-workflow-version-step.input';+import { type CreateCoreWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/create-core-workflow-version-step.input';import { type WorkflowVersionStepChangesDTO } from 'src/engine/core-modules/workflow/dtos/workflow-version-step-changes.dto';import {type WorkflowToolContext,@@ -10,10 +10,10 @@ import {} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const baseStepFields = {- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version to add the step to'),+ .describe('The core workflow version UUID to add the step to'),parentStepId: z.string().optional()@@ -93,9 +93,7 @@ const enrichResultWithNextStep = ({export const createCreateWorkflowVersionStepTool = (deps: Pick<WorkflowToolDependencies,- | 'workflowVersionStepService'- | 'workflowVersionStepHelpersService'- | 'workflowVersionService'+ 'coreWorkflowVersionMutationService' | 'coreWorkflowVersionWriteService'>,context: WorkflowToolContext,) => ({@@ -103,51 +101,55 @@ export const createCreateWorkflowVersionStepTool = (description:'Create a new step in a workflow version. This adds a step to the specified workflow version with the given configuration. If parentStepId is not provided, the step will be appended at the end of the workflow.',inputSchema: createWorkflowVersionStepSchema,- execute: async (parameters: CreateWorkflowVersionStepInput) => {+ execute: async (parameters: CreateCoreWorkflowVersionStepInput) => {try {+ const { workspaceId } = context;+ const { coreWorkflowVersionId } = parameters;+let effectiveParentStepId = parameters.parentStepId;if (!isDefined(effectiveParentStepId)) {- const workflowVersion =- await deps.workflowVersionStepHelpersService.getValidatedDraftWorkflowVersion(+ const { steps } =+ await deps.coreWorkflowVersionWriteService.getValidatedDraftCoreWorkflowVersion({- workflowVersionId: parameters.workflowVersionId,- workspaceId: context.workspaceId,+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId,},);- const steps = workflowVersion.steps ?? [];+ const existingSteps = steps ?? [];- if (steps.length === 0) {+ if (existingSteps.length === 0) {effectiveParentStepId = TRIGGER_STEP_ID;} else {- const leafStep = steps.filter(+ const leafSteps = existingSteps.filter((step) =>!isDefined(step.nextStepIds) || step.nextStepIds.length === 0,);- if (leafStep.length > 1) {- effectiveParentStepId = undefined;- } else {- effectiveParentStepId = leafStep[0]?.id;- }+ effectiveParentStepId =+ leafSteps.length > 1 ? undefined : leafSteps[0]?.id;}}- const result =- await deps.workflowVersionStepService.createWorkflowVersionStep({- workspaceId: context.workspaceId,- input: {- ...parameters,- parentStepId: effectiveParentStepId,- },- });-- await deps.workflowVersionService.autoLayoutWorkflowVersion({- workflowVersionId: parameters.workflowVersionId,- workspaceId: context.workspaceId,+ const result = await deps.coreWorkflowVersionMutationService.createStep({+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ input: {+ ...parameters,+ parentStepId: effectiveParentStepId,+ },});+ await deps.coreWorkflowVersionMutationService.autoLayoutCoreWorkflowVersion(+ {+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId,+ },+ );+return enrichResultWithNextStep({result,stepType: parameters.stepType,diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.tsindex 23e38b42b43..75040d8e1a3 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/deactivate-workflow-version.tool.ts@@ -6,10 +6,10 @@ import {} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const deactivateWorkflowVersionSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version to deactivate'),+ .describe('The core workflow version UUID to deactivate'),});type DeactivateWorkflowVersionInput = z.infer<@@ -17,7 +17,7 @@ type DeactivateWorkflowVersionInput = z.infer<>;export const createDeactivateWorkflowVersionTool = (- deps: Pick<WorkflowToolDependencies, 'workflowTriggerService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowLifecycleService'>,context: WorkflowToolContext,) => ({name: 'deactivate_workflow_version' as const,@@ -26,9 +26,12 @@ export const createDeactivateWorkflowVersionTool = (inputSchema: deactivateWorkflowVersionSchema,execute: async (parameters: DeactivateWorkflowVersionInput) => {try {- return await deps.workflowTriggerService.deactivateWorkflowVersion(- parameters.workflowVersionId,- context.workspaceId,+ return await deps.coreWorkflowLifecycleService.deactivateCoreWorkflowVersion(+ {+ workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,+ },);} catch (error) {return {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.tsindex 0447eedb71e..f23117df62d 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-edge.tool.ts@@ -7,10 +7,10 @@ import {} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const deleteWorkflowVersionEdgeSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version'),+ .describe('The core workflow version UUID'),source: z.union([z.literal('trigger'), z.string().uuid()]).describe('The source step: "trigger" or a step UUID'),@@ -23,7 +23,7 @@ type DeleteWorkflowVersionEdgeInput = z.infer<>;export const createDeleteWorkflowVersionEdgeTool = (- deps: Pick<WorkflowToolDependencies, 'workflowVersionEdgeService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,context: WorkflowToolContext,) => ({name: 'delete_workflow_version_edge' as const,@@ -31,11 +31,12 @@ export const createDeleteWorkflowVersionEdgeTool = (inputSchema: deleteWorkflowVersionEdgeSchema,execute: async (parameters: DeleteWorkflowVersionEdgeInput) => {try {- return await deps.workflowVersionEdgeService.deleteWorkflowVersionEdge({+ return await deps.coreWorkflowVersionMutationService.deleteEdge({source: parameters.source,target: parameters.target,- workflowVersionId: parameters.workflowVersionId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,sourceConnectionOptions: parameters.sourceConnectionOptions,});} catch (error) {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.tsindex c3cba2c0165..64948ac6458 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow-version-step.tool.ts@@ -6,10 +6,10 @@ import {} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const deleteWorkflowVersionStepSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version containing the step'),+ .describe('The core workflow version UUID containing the step'),stepId: z.string().uuid().describe('The UUID of the step to delete'),});@@ -18,7 +18,7 @@ type DeleteWorkflowVersionStepInput = z.infer<>;export const createDeleteWorkflowVersionStepTool = (- deps: Pick<WorkflowToolDependencies, 'workflowVersionStepService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,context: WorkflowToolContext,) => ({name: 'delete_workflow_version_step' as const,@@ -27,9 +27,10 @@ export const createDeleteWorkflowVersionStepTool = (inputSchema: deleteWorkflowVersionStepSchema,execute: async (parameters: DeleteWorkflowVersionStepInput) => {try {- return await deps.workflowVersionStepService.deleteWorkflowVersionStep({+ return await deps.coreWorkflowVersionMutationService.deleteStep({workspaceId: context.workspaceId,- workflowVersionId: parameters.workflowVersionId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,stepIdToDelete: parameters.stepId,});} catch (error) {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.tsindex c104731f8bd..ff6dea81bb4 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/delete-workflow.tool.ts@@ -1,20 +1,16 @@+import { isDefined } from 'twenty-shared/utils';import { z } from 'zod';-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';-import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';import {type WorkflowToolContext,type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';-import { isDefined } from 'twenty-shared/utils';--type DeleteWorkflowToolContext = WorkflowToolContext & {- rolePermissionConfig: RolePermissionConfig;-};const deleteWorkflowSchema = z.object({- workflowId: z.string().uuid().describe('The UUID of the workflow to delete'),+ coreWorkflowId: z+ .string()+ .uuid()+ .describe('The core workflow UUID to delete'),});type DeleteWorkflowInput = z.infer<typeof deleteWorkflowSchema>;@@ -22,50 +18,43 @@ type DeleteWorkflowInput = z.infer<typeof deleteWorkflowSchema>;export const createDeleteWorkflowTool = (deps: Pick<WorkflowToolDependencies,- 'workspaceOrmManager' | 'workflowCommonService'+ 'coreWorkflowListService' | 'coreWorkflowMutationService'>,- context: DeleteWorkflowToolContext,+ context: WorkflowToolContext,) => ({name: 'delete_workflow' as const,description:- 'Delete a workflow by its ID. This also removes its versions, runs and automated triggers, and deactivates any active version. Use list_workflows to find the workflowId.',+ 'Delete a workflow by its core workflow ID. This also removes its versions, runs and automated triggers, and deactivates any active version. Use list_workflows to find the coreWorkflowId.',inputSchema: deleteWorkflowSchema,execute: async (parameters: DeleteWorkflowInput) => {try {- const { workflowId } = parameters;+ const { coreWorkflowId } = parameters;const { workspaceId } = context;- const authContext = buildSystemAuthContext(workspaceId);-- const deleteResult =- await deps.workspaceOrmManager.executeInWorkspaceContext(async () => {- const workflowRepository =- deps.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(- 'workflow',- context.rolePermissionConfig,- );-- return workflowRepository.softDelete(workflowId);- }, authContext);+ const coreWorkflow = await deps.coreWorkflowListService.findOneById({+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowId,+ });- if (!isDefined(deleteResult.affected)) {+ if (!isDefined(coreWorkflow)) {return {success: false,error: 'Workflow not found',- message: `No workflow found with ID ${workflowId}`,+ message: `No workflow found with core ID ${coreWorkflowId}`,};}- await deps.workflowCommonService.handleWorkflowSubEntities({- workflowIds: [workflowId],+ await deps.coreWorkflowMutationService.deleteWorkflows({workspaceId,- operation: 'delete',+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowIds: [coreWorkflowId],});return {success: true,- message: `Successfully deleted workflow ${workflowId}`,- workflowId,+ message: `Successfully deleted workflow ${coreWorkflowId}`,+ coreWorkflowId,};} catch (error) {const errorMessage =diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.tsindex 6c44bb57b45..0a0d2f2ddf1 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-current-version.tool.ts@@ -1,27 +1,19 @@import { isDefined } from 'twenty-shared/utils';import { z } from 'zod';-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';-import {- WorkflowVersionStatus,- type WorkflowVersionWorkspaceEntity,-} from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';-import { type WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';+import { WorkflowVersionStatus as CoreWorkflowVersionStatus } from 'src/engine/core-modules/workflow/entities/workflow-version.entity';import {type WorkflowToolContext,type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';-type GetWorkflowCurrentVersionToolContext = WorkflowToolContext & {- rolePermissionConfig: RolePermissionConfig;-};-const getWorkflowCurrentVersionSchema = z.object({- workflowId: z+ coreWorkflowId: z.string().uuid()- .describe('The UUID of the workflow to get the current version for'),+ .describe(+ 'The core workflow UUID to get the current version for, as returned by list_workflows',+ ),});type GetWorkflowCurrentVersionInput = z.infer<@@ -29,85 +21,86 @@ type GetWorkflowCurrentVersionInput = z.infer<>;export const createGetWorkflowCurrentVersionTool = (- deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context: GetWorkflowCurrentVersionToolContext,+ deps: Pick<+ WorkflowToolDependencies,+ 'coreWorkflowListService' | 'coreWorkflowVersionListService'+ >,+ context: WorkflowToolContext,) => ({name: 'get_workflow_current_version' as const,description:- 'Get the current version of a workflow. Returns the draft version if one exists, otherwise the last published version.',+ 'Get the current version of a workflow. Returns the draft version if one exists, otherwise the last published version. Returns a core workflow version ID (coreWorkflowVersionId), which the editing tools expect.',inputSchema: getWorkflowCurrentVersionSchema,execute: async (parameters: GetWorkflowCurrentVersionInput) => {try {- const authContext = buildSystemAuthContext(context.workspaceId);-- return await deps.workspaceOrmManager.executeInWorkspaceContext(- async () => {- const workflowRepository =- deps.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(- 'workflow',- context.rolePermissionConfig,- );+ const { workspaceId } = context;+ const { coreWorkflowId } = parameters;- const workflow = await workflowRepository.findOne({- where: { id: parameters.workflowId },- });+ const coreWorkflow = await deps.coreWorkflowListService.findOneById({+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowId,+ });- if (!isDefined(workflow)) {- return {- success: false,- error: `Workflow ${parameters.workflowId} not found`,- };- }+ if (!isDefined(coreWorkflow)) {+ return {+ success: false,+ error: `Workflow ${coreWorkflowId} not found`,+ };+ }- const workflowVersionRepository =- deps.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(- 'workflowVersion',- context.rolePermissionConfig,- );+ const coreWorkflowVersions =+ await deps.coreWorkflowVersionListService.findManyByCoreWorkflowId({+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowId,+ });- const versions = await workflowVersionRepository.find({- where: [- {- workflowId: parameters.workflowId,- status: WorkflowVersionStatus.DRAFT,- },- {- workflowId: parameters.workflowId,- status: WorkflowVersionStatus.ACTIVE,- },- ],- });+ const currentVersion =+ coreWorkflowVersions.find(+ (version) => version.status === CoreWorkflowVersionStatus.DRAFT,+ ) ??+ coreWorkflowVersions.find(+ (version) => version.status === CoreWorkflowVersionStatus.ACTIVE,+ ) ??+ coreWorkflowVersions.find(+ (version) => version.status === CoreWorkflowVersionStatus.DEACTIVATED,+ );- const draftVersion = versions.find(- (version) => version.status === WorkflowVersionStatus.DRAFT,- );- const activeVersion = versions.find(- (version) => version.status === WorkflowVersionStatus.ACTIVE,- );+ if (!isDefined(currentVersion)) {+ return {+ success: false,+ error: `Workflow ${coreWorkflowId} has no draft, active or deactivated version`,+ };+ }- const currentVersion = draftVersion ?? activeVersion;+ const coreWorkflowVersion =+ await deps.coreWorkflowVersionListService.findOneByCoreWorkflowVersionId(+ {+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: currentVersion.id,+ },+ );- if (!isDefined(currentVersion)) {- return {- success: false,- error: `Workflow ${parameters.workflowId} has no draft or active version`,- };- }+ if (!isDefined(coreWorkflowVersion)) {+ return {+ success: false,+ error: `Workflow version ${currentVersion.id} not found`,+ };+ }- return {- success: true,- workflowVersion: {- id: currentVersion.id,- name: currentVersion.name,- status: currentVersion.status,- trigger: currentVersion.trigger,- steps: currentVersion.steps,- workflowId: currentVersion.workflowId,- },- };+ return {+ success: true,+ workflowVersion: {+ coreWorkflowVersionId: coreWorkflowVersion.id,+ name: coreWorkflowVersion.label,+ status: coreWorkflowVersion.status,+ trigger: coreWorkflowVersion.trigger,+ steps: coreWorkflowVersion.steps,+ coreWorkflowId,},- authContext,- );+ };} catch (error) {return {success: false,diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.tsindex 81f6c0e5e85..0fbbf49395e 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/get-workflow-run.tool.ts@@ -2,7 +2,6 @@ import { isDefined } from 'twenty-shared/utils';import { StepStatus } from 'twenty-shared/workflow';import { z } from 'zod';-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';import { type WorkflowRunWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';import {@@ -10,10 +9,6 @@ import {type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';-type GetWorkflowRunToolContext = WorkflowToolContext & {- rolePermissionConfig: RolePermissionConfig;-};-const getWorkflowRunSchema = z.object({workflowRunId: z.uuid().describe('The UUID of the workflow run to inspect'),});@@ -27,7 +22,7 @@ const FAILED_STEP_STATUSES: StepStatus[] = [export const createGetWorkflowRunTool = (deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context: GetWorkflowRunToolContext,+ context: WorkflowToolContext,) => ({name: 'get_workflow_run' as const,description:@@ -92,8 +87,8 @@ export const createGetWorkflowRunTool = (startedAt: workflowRun.startedAt,endedAt: workflowRun.endedAt,enqueuedAt: workflowRun.enqueuedAt,- workflowId: workflowRun.workflowId,- workflowVersionId: workflowRun.workflowVersionId,+ coreWorkflowId: workflowRun.coreWorkflowId,+ coreWorkflowVersionId: workflowRun.coreWorkflowVersionId,steps,failedStepLogs,},diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.tsindex eb4f7ece63a..324ff665850 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflow-runs.tool.ts@@ -2,7 +2,6 @@ import { isDefined } from 'twenty-shared/utils';import { type FindOptionsWhere } from 'typeorm';import { z } from 'zod';-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';import {WorkflowRunStatus,@@ -13,18 +12,16 @@ import {type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';-type ListWorkflowRunsToolContext = WorkflowToolContext & {- rolePermissionConfig: RolePermissionConfig;-};-const DEFAULT_LIMIT = 10;const MAX_LIMIT = 50;const listWorkflowRunsSchema = z.object({- workflowId: z+ coreWorkflowId: z.uuid().optional()- .describe('Filter runs by the UUID of the workflow they belong to'),+ .describe(+ 'Filter runs by the core workflow UUID they belong to, as returned by list_workflows',+ ),status: z.nativeEnum(WorkflowRunStatus).optional()@@ -44,11 +41,11 @@ type ListWorkflowRunsInput = z.infer<typeof listWorkflowRunsSchema>;export const createListWorkflowRunsTool = (deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context: ListWorkflowRunsToolContext,+ context: WorkflowToolContext,) => ({name: 'list_workflow_runs' as const,description:- 'List workflow runs, optionally filtered by workflow and/or status, ordered from most to least recent. Use this to find the relevant run (for example the latest failed run of a workflow) before inspecting it in detail with get_workflow_run.',+ 'List workflow runs, optionally filtered by core workflow and/or status, ordered from most to least recent. Use this to find the relevant run (for example the latest failed run of a workflow) before inspecting it in detail with get_workflow_run.',inputSchema: listWorkflowRunsSchema,execute: async (parameters: ListWorkflowRunsInput) => {try {@@ -64,8 +61,8 @@ export const createListWorkflowRunsTool = (const where: FindOptionsWhere<WorkflowRunWorkspaceEntity> = {};- if (isDefined(parameters.workflowId)) {- where.workflowId = parameters.workflowId;+ if (isDefined(parameters.coreWorkflowId)) {+ where.coreWorkflowId = parameters.coreWorkflowId;}if (isDefined(parameters.status)) {@@ -87,8 +84,8 @@ export const createListWorkflowRunsTool = (error: workflowRun.state?.workflowRunError,startedAt: workflowRun.startedAt,endedAt: workflowRun.endedAt,- workflowId: workflowRun.workflowId,- workflowVersionId: workflowRun.workflowVersionId,+ coreWorkflowId: workflowRun.coreWorkflowId,+ coreWorkflowVersionId: workflowRun.coreWorkflowVersionId,})),};},diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.tsindex 879f4b96ada..abb41a4fd4b 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/list-workflows.tool.ts@@ -1,84 +1,89 @@import { z } from 'zod';-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';import {- WorkflowStatus,- type WorkflowWorkspaceEntity,-} from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';+ CoreWorkflowFilterFieldKey,+ CoreWorkflowFilterLogicalOperator,+ CoreWorkflowFilterOperand,+} from 'src/engine/core-modules/workflow/dtos/core-workflow-filter.input';+import {+ CoreWorkflowOrderByDirection,+ CoreWorkflowOrderByField,+} from 'src/engine/core-modules/workflow/dtos/core-workflows.input';+import { WorkflowStatus } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';import {type WorkflowToolContext,type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';-type ListWorkflowsToolContext = WorkflowToolContext & {- rolePermissionConfig: RolePermissionConfig;-};+const DEFAULT_LIST_WORKFLOWS_LIMIT = 50;const listWorkflowsSchema = z.object({status: z.nativeEnum(WorkflowStatus).optional().describe('Filter by status (DRAFT, ACTIVE, DEACTIVATED)'),- limit: z.number().int().min(1).max(100).optional().default(50),- offset: z.number().int().min(0).optional().default(0),+ limit: z+ .number()+ .int()+ .min(1)+ .max(100)+ .optional()+ .default(DEFAULT_LIST_WORKFLOWS_LIMIT),+ after: z+ .string()+ .optional()+ .describe(+ 'Cursor returned as endCursor by a previous call, to fetch the next page',+ ),});type ListWorkflowsInput = z.infer<typeof listWorkflowsSchema>;export const createListWorkflowsTool = (- deps: Pick<WorkflowToolDependencies, 'workspaceOrmManager'>,- context: ListWorkflowsToolContext,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowListService'>,+ context: WorkflowToolContext,) => ({name: 'list_workflows' as const,description:- 'List all workflows in the workspace. Supports filtering by status and pagination.',+ 'List all workflows in the workspace. Supports filtering by status and cursor pagination. Returns core workflow IDs (coreWorkflowId), which every other workflow tool expects. Use get_workflow_current_version to get the workflow current core version.',inputSchema: listWorkflowsSchema,execute: async (parameters: ListWorkflowsInput) => {try {- const authContext = buildSystemAuthContext(context.workspaceId);-- return await deps.workspaceOrmManager.executeInWorkspaceContext(- async () => {- const workflowRepository =- deps.workspaceOrmManager.getRepository<WorkflowWorkspaceEntity>(- 'workflow',- context.rolePermissionConfig,- );-- const queryBuilder =- workflowRepository.createQueryBuilder('workflow');+ const { edges, pageInfo, totalCount } =+ await deps.coreWorkflowListService.findManyByWorkspaceId({+ workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ first: parameters.limit ?? DEFAULT_LIST_WORKFLOWS_LIMIT,+ after: parameters.after,+ orderBy: CoreWorkflowOrderByField.UPDATED_AT,+ orderByDirection: CoreWorkflowOrderByDirection.DESC,+ filter: parameters.status+ ? {+ logicalOperator: CoreWorkflowFilterLogicalOperator.AND,+ rules: [+ {+ fieldKey: CoreWorkflowFilterFieldKey.STATUSES,+ operand: CoreWorkflowFilterOperand.CONTAINS,+ value: JSON.stringify([parameters.status]),+ },+ ],+ }+ : undefined,+ });- if (parameters.status) {- queryBuilder.where(':status = ANY(workflow.statuses)', {- status: parameters.status,- });- }-- queryBuilder- .orderBy('workflow.createdAt', 'DESC')- .take(parameters.limit)- .skip(parameters.offset);-- const workflows =- await queryBuilder.getMany<WorkflowWorkspaceEntity>();- const totalCount = await queryBuilder.getCount();-- return {- success: true,- workflows: workflows.map((workflow) => ({- id: workflow.id,- name: workflow.name,- statuses: workflow.statuses,- lastPublishedVersionId: workflow.lastPublishedVersionId,- createdAt: workflow.createdAt,- updatedAt: workflow.updatedAt,- })),- totalCount,- };- },- authContext,- );+ return {+ success: true,+ workflows: edges.map(({ node }) => ({+ coreWorkflowId: node.id,+ name: node.name,+ statuses: node.statuses,+ createdAt: node.createdAt,+ updatedAt: node.updatedAt,+ })),+ totalCount,+ endCursor: pageInfo.endCursor,+ hasNextPage: pageInfo.hasNextPage,+ };} catch (error) {const errorMessage =error instanceof Error ? error.message : String(error);diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.tsindex 55caa9b8cd4..ea821db1164 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-agent.tool.ts@@ -4,10 +4,6 @@ import { z } from 'zod';import { type AgentResponseFormat } from 'src/engine/metadata-modules/ai/ai-agent/types/agent-response-format.type';import { type ModelId } from 'src/engine/metadata-modules/ai/ai-models/types/model-id.type';-import {- WorkflowVersionStatus,- type WorkflowVersionWorkspaceEntity,-} from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';import {type WorkflowToolContext,type WorkflowToolDependencies,@@ -61,35 +57,32 @@ const updateAgentSchema = z.object({const resyncAiAgentStepOutputSchemas = async (deps: Pick<WorkflowToolDependencies,- | 'workflowVersionStepService'- | 'workspaceOrmManager'+ | 'coreWorkflowVersionListService'+ | 'coreWorkflowVersionMutationService'| 'flatEntityMapsCacheService'>,- { workspaceId, agentId }: { workspaceId: string; agentId: string },+ {+ workspaceId,+ userWorkspaceId,+ agentId,+ }: {+ workspaceId: string;+ userWorkspaceId: string | undefined;+ agentId: string;+ },): Promise<void> => {await deps.flatEntityMapsCacheService.invalidateFlatEntityMaps({workspaceId,flatMapsKeys: ['flatAgentMaps'],});- const workflowVersionRepository =- deps.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(- 'workflowVersion',- { shouldBypassPermissionChecks: true },- );-- const draftVersions = await workflowVersionRepository.find({- where: { status: WorkflowVersionStatus.DRAFT },- });-- for (const version of draftVersions) {- const steps = version.steps;-- if (!isDefined(steps)) {- continue;- }+ const draftCoreVersions =+ await deps.coreWorkflowVersionListService.findDraftCoreWorkflowVersions({+ workspaceId,+ });- const matchingStep = steps.find(+ for (const draftCoreVersion of draftCoreVersions) {+ const matchingStep = draftCoreVersion.steps?.find((step) =>step.type === WorkflowActionType.AI_AGENT &&step.settings?.input?.agentId === agentId,@@ -99,9 +92,10 @@ const resyncAiAgentStepOutputSchemas = async (continue;}- await deps.workflowVersionStepService.updateWorkflowVersionStep({+ await deps.coreWorkflowVersionMutationService.updateStep({workspaceId,- workflowVersionId: version.id,+ userWorkspaceId,+ coreWorkflowVersionId: draftCoreVersion.id,step: matchingStep,});}@@ -111,8 +105,8 @@ export const createUpdateAgentTool = (deps: Pick<WorkflowToolDependencies,| 'agentService'- | 'workflowVersionStepService'- | 'workspaceOrmManager'+ | 'coreWorkflowVersionListService'+ | 'coreWorkflowVersionMutationService'| 'flatEntityMapsCacheService'>,context: WorkflowToolContext,@@ -150,7 +144,11 @@ To find the agentId, look at the AI_AGENT step's settings.input.agentId field.`,if (isDefined(responseFormat)) {try {- await resyncAiAgentStepOutputSchemas(deps, { workspaceId, agentId });+ await resyncAiAgentStepOutputSchemas(deps, {+ workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ agentId,+ });} catch (resyncError) {return {success: true,diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.tsindex 4985426f67f..a65e464122b 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-positions.tool.ts@@ -1,16 +1,16 @@import { z } from 'zod';-import type { UpdateWorkflowVersionPositionsInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-positions.input';+import { type WorkflowStepPositionUpdateInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-step-position-update.input';import {type WorkflowToolContext,type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const updateWorkflowVersionPositionsSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version'),+ .describe('The core workflow version UUID'),positions: z.array(z.object({@@ -25,19 +25,23 @@ const updateWorkflowVersionPositionsSchema = z.object({});export const createUpdateWorkflowVersionPositionsTool = (- deps: Pick<WorkflowToolDependencies, 'workflowVersionService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,context: WorkflowToolContext,) => ({name: 'update_workflow_version_positions' as const,description:'Update the positions of multiple workflow steps. This is useful for reorganizing the workflow layout.',inputSchema: updateWorkflowVersionPositionsSchema,- execute: async (parameters: UpdateWorkflowVersionPositionsInput) => {+ execute: async (parameters: {+ coreWorkflowVersionId: string;+ positions: WorkflowStepPositionUpdateInput[];+ }) => {try {- return await deps.workflowVersionService.updateWorkflowVersionPositions({- workflowVersionId: parameters.workflowVersionId,+ return await deps.coreWorkflowVersionMutationService.updatePositions({+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,positions: parameters.positions,workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,});} catch (error) {return {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.tsindex 1e9f722e0bc..d15141a2050 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-step.tool.ts@@ -1,35 +1,39 @@import { workflowActionSchema } from 'twenty-shared/workflow';import { z } from 'zod';-import type { UpdateWorkflowVersionStepInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-step.input';+import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';import {type WorkflowToolContext,type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const updateWorkflowVersionStepSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version containing the step'),+ .describe('The core workflow version UUID containing the step'),step: z.union([workflowActionSchema]).describe('The updated step configuration'),});export const createUpdateWorkflowVersionStepTool = (- deps: Pick<WorkflowToolDependencies, 'workflowVersionStepService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,context: WorkflowToolContext,) => ({name: 'update_workflow_version_step' as const,description:'Update an existing step in a workflow version. This modifies the step configuration. Call validate_workflow once after your edits are done, not after every change.',inputSchema: updateWorkflowVersionStepSchema,- execute: async (parameters: UpdateWorkflowVersionStepInput) => {+ execute: async (parameters: {+ coreWorkflowVersionId: string;+ step: WorkflowAction;+ }) => {try {- return await deps.workflowVersionStepService.updateWorkflowVersionStep({+ return await deps.coreWorkflowVersionMutationService.updateStep({workspaceId: context.workspaceId,- workflowVersionId: parameters.workflowVersionId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,step: parameters.step,});} catch (error) {diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.tsindex 9c2d5eb2697..0b1fe9986f3 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/update-workflow-version-trigger.tool.ts@@ -1,46 +1,42 @@import { workflowTriggerSchema } from 'twenty-shared/workflow';import { z } from 'zod';-import type { UpdateWorkflowVersionTriggerInput } from 'src/engine/core-modules/workflow/dtos/update-workflow-version-trigger.input';import {type WorkflowToolContext,type WorkflowToolDependencies,} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';+import { type WorkflowTrigger } from 'src/modules/workflow/workflow-trigger/types/workflow-trigger.type';const updateWorkflowVersionTriggerSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version containing the trigger'),+ .describe('The core workflow version UUID containing the trigger'),trigger: workflowTriggerSchema.describe('The updated trigger configuration'),});export const createUpdateWorkflowVersionTriggerTool = (- deps: Pick<WorkflowToolDependencies, 'workflowVersionStepHelpersService'>,+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowVersionMutationService'>,context: WorkflowToolContext,) => ({name: 'update_workflow_version_trigger' as const,description:'Update the trigger of a workflow version. This modifies the trigger configuration (e.g., changing trigger type, settings, or conditions).',inputSchema: updateWorkflowVersionTriggerSchema,- execute: async (parameters: UpdateWorkflowVersionTriggerInput) => {+ execute: async (parameters: {+ coreWorkflowVersionId: string;+ trigger: WorkflowTrigger;+ }) => {try {- await deps.workflowVersionStepHelpersService.getValidatedDraftWorkflowVersion(- {- workflowVersionId: parameters.workflowVersionId,+ const { trigger } =+ await deps.coreWorkflowVersionMutationService.updateTrigger({workspaceId: context.workspaceId,- },- );-- await deps.workflowVersionStepHelpersService.updateWorkflowVersionStepsAndTrigger(- {- workspaceId: context.workspaceId,- workflowVersionId: parameters.workflowVersionId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,trigger: parameters.trigger,- },- );+ });- return parameters.trigger;+ return trigger;} catch (error) {return {success: false,diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.tsindex d74215dd346..10315e602c1 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/tools/validate-workflow.tool.ts@@ -1,24 +1,22 @@import { z } from 'zod';-import { type WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';import { WorkflowVersionValidationException } from 'src/modules/workflow/workflow-builder/workflow-validation/exceptions/workflow-version-validation.exception';-import { type WorkflowVersionValidationWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.workspace-service';-import { type WorkflowToolContext } from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';+import {+ type WorkflowToolContext,+ type WorkflowToolDependencies,+} from 'src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type';const validateWorkflowSchema = z.object({- workflowVersionId: z+ coreWorkflowVersionId: z.string().uuid()- .describe('The UUID of the workflow version to validate'),+ .describe('The core workflow version UUID to validate'),});type ValidateWorkflowInput = z.infer<typeof validateWorkflowSchema>;export const createValidateWorkflowTool = (- deps: {- workflowCommonService: WorkflowCommonWorkspaceService;- workflowVersionValidationWorkspaceService: WorkflowVersionValidationWorkspaceService;- },+ deps: Pick<WorkflowToolDependencies, 'coreWorkflowLifecycleService'>,context: WorkflowToolContext,) => ({name: 'validate_workflow' as const,@@ -27,19 +25,11 @@ export const createValidateWorkflowTool = (inputSchema: validateWorkflowSchema,execute: async (parameters: ValidateWorkflowInput) => {try {- const workflowVersion =- await deps.workflowCommonService.getWorkflowVersionOrFail({- workspaceId: context.workspaceId,- workflowVersionId: parameters.workflowVersionId,- });-- await deps.workflowVersionValidationWorkspaceService.assertWorkflowVersionIsActivableOrThrow(- {- workspaceId: context.workspaceId,- trigger: workflowVersion.trigger,- steps: workflowVersion.steps,- },- );+ await deps.coreWorkflowLifecycleService.validateCoreWorkflowVersion({+ workspaceId: context.workspaceId,+ userWorkspaceId: context.userWorkspaceId,+ coreWorkflowVersionId: parameters.coreWorkflowVersionId,+ });return {success: true,diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.tsindex 2bf02d53551..a875148f4fe 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/types/workflow-tool-dependencies.type.ts@@ -1,35 +1,35 @@-import type { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';-import type { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';+import type { ActorMetadata } from 'twenty-shared/types';++import type { CoreWorkflowLifecycleWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-lifecycle.workspace-service';+import type { CoreWorkflowListService } from 'src/engine/core-modules/workflow/services/core-workflow-list.service';+import type { CoreWorkflowMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-mutation.workspace-service';+import type { CoreWorkflowVersionListService } from 'src/engine/core-modules/workflow/services/core-workflow-version-list.service';+import type { CoreWorkflowVersionMutationWorkspaceService } from 'src/engine/core-modules/workflow/services/core-workflow-version-mutation.workspace-service';+import type { CoreWorkflowVersionWriteService } from 'src/engine/core-modules/workflow/services/core-workflow-version-write.service';import type { AgentService } from 'src/engine/metadata-modules/ai/ai-agent/agent.service';-import type { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logic-function/services/logic-function-from-source.service';import type { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';+import type { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logic-function/services/logic-function-from-source.service';+import type { RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';import type { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';-import type { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';import type { WorkflowSchemaWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.workspace-service';-import type { WorkflowVersionValidationWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.workspace-service';-import type { WorkflowVersionEdgeWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.workspace-service';-import type { WorkflowVersionStepHelpersWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-helpers.workspace-service';-import type { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.workspace-service';-import type { WorkflowVersionWorkspaceService } from 'src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service';-import type { WorkflowTriggerWorkspaceService } from 'src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service';export type WorkflowToolDependencies = {- workflowVersionStepService: WorkflowVersionStepWorkspaceService;- workflowVersionStepHelpersService: WorkflowVersionStepHelpersWorkspaceService;- workflowVersionEdgeService: WorkflowVersionEdgeWorkspaceService;- workflowVersionService: WorkflowVersionWorkspaceService;- workflowTriggerService: WorkflowTriggerWorkspaceService;+ coreWorkflowListService: CoreWorkflowListService;+ coreWorkflowVersionListService: CoreWorkflowVersionListService;+ coreWorkflowMutationService: CoreWorkflowMutationWorkspaceService;+ coreWorkflowVersionMutationService: CoreWorkflowVersionMutationWorkspaceService;+ coreWorkflowVersionWriteService: CoreWorkflowVersionWriteService;+ coreWorkflowLifecycleService: CoreWorkflowLifecycleWorkspaceService;workflowSchemaService: WorkflowSchemaWorkspaceService;- workflowVersionValidationWorkspaceService: WorkflowVersionValidationWorkspaceService;workspaceOrmManager: WorkspaceOrmManager;- recordPositionService: RecordPositionService;logicFunctionFromSourceService: LogicFunctionFromSourceService;flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService;agentService: AgentService;- workflowCommonService: WorkflowCommonWorkspaceService;- workflowVersionCoreSyncService: WorkflowVersionCoreSyncService;};export type WorkflowToolContext = {workspaceId: string;+ rolePermissionConfig: RolePermissionConfig;+ actorContext?: ActorMetadata;+ userWorkspaceId?: string;};diff --git a/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.ts b/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.tsindex bca6621d143..35294b972cd 100644--- a/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-tools/workflow-tools.module.ts@@ -1,18 +1,11 @@import { Global, Module } from '@nestjs/common';-import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';import { WORKFLOW_TOOL_SERVICE_TOKEN } from 'src/engine/core-modules/tool-provider/constants/workflow-tool-service.token';+import { CoreWorkflowServicesModule } from 'src/engine/core-modules/workflow/core-workflow-services.module';import { AiAgentModule } from 'src/engine/metadata-modules/ai/ai-agent/ai-agent.module';import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';import { LogicFunctionModule } from 'src/engine/metadata-modules/logic-function/logic-function.module';-import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';-import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';import { WorkflowSchemaModule } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.module';-import { WorkflowVersionValidationModule } from 'src/modules/workflow/workflow-builder/workflow-validation/workflow-version-validation.module';-import { WorkflowVersionEdgeModule } from 'src/modules/workflow/workflow-builder/workflow-version-edge/workflow-version-edge.module';-import { WorkflowVersionStepModule } from 'src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.module';-import { WorkflowVersionModule } from 'src/modules/workflow/workflow-builder/workflow-version/workflow-version.module';-import { WorkflowTriggerModule } from 'src/modules/workflow/workflow-trigger/workflow-trigger.module';import { WorkflowToolWorkspaceService } from './services/workflow-tool.workspace-service';@@ -21,18 +14,11 @@ import { WorkflowToolWorkspaceService } from './services/workflow-tool.workspace@Global()@Module({imports: [- WorkflowVersionStepModule,- WorkflowVersionEdgeModule,- WorkflowVersionModule,- WorkflowTriggerModule,- WorkflowCommonModule,+ CoreWorkflowServicesModule,WorkflowSchemaModule,- WorkflowVersionValidationModule,- RecordPositionModule,LogicFunctionModule,WorkspaceManyOrAllFlatEntityMapsCacheModule,AiAgentModule,- WorkflowVersionCoreModule,],providers: [WorkflowToolWorkspaceService,diff --git a/packages/twenty-server/test/integration/ai/suites/workflow-tools-core-ids.integration-spec.ts b/packages/twenty-server/test/integration/ai/suites/workflow-tools-core-ids.integration-spec.tsnew file mode 100644index 00000000000..9035717abb3--- /dev/null+++ b/packages/twenty-server/test/integration/ai/suites/workflow-tools-core-ids.integration-spec.ts@@ -0,0 +1,447 @@+import { randomUUID } from 'node:crypto';++import request from 'supertest';++const TEST_WORKSPACE_SCHEMA = 'workspace_1wgvd1injqtife6y4rvfbu3h5';++type McpToolCallResult = {+ content?: Array<{ type: string; text: string }>;+ isError?: boolean;+};++const baseUrl = `http://localhost:${APP_PORT}`;++const postMcp = (body: Record<string, unknown>) =>+ request(baseUrl)+ .post('/mcp')+ .set('Authorization', `Bearer ${API_KEY_ACCESS_TOKEN}`)+ .set('Content-Type', 'application/json')+ .set('Accept', 'application/json')+ .send(JSON.stringify(body));++const callWorkflowTool = async <TResult>(+ toolName: string,+ args: Record<string, unknown>,+): Promise<TResult> => {+ const response = await postMcp({+ jsonrpc: '2.0',+ method: 'tools/call',+ id: `call-${randomUUID()}`,+ params: {+ name: 'execute_tool',+ arguments: { toolName, arguments: args },+ },+ }).expect(200);++ expect(response.body.error).toBeUndefined();++ const result = response.body.result as McpToolCallResult;+ const raw = result.content?.[0]?.text;++ expect(raw).toBeDefined();++ return JSON.parse(raw as string) as TResult;+};++const TRIGGER_ID = 'trigger';++const buildManualTrigger = () => ({+ name: 'Manual Trigger',+ type: 'MANUAL',+ settings: { outputSchema: {} },+ nextStepIds: [],+ position: { x: 0, y: 0 },+});++const buildIteratorStep = (id: string) => ({+ id,+ name: 'Loop over items',+ type: 'ITERATOR',+ valid: true,+ settings: {+ input: { items: ['a', 'b'] },+ outputSchema: {},+ errorHandlingOptions: {+ retryOnFailure: { value: 0 },+ continueOnFailure: { value: false },+ },+ },+ nextStepIds: [],+});++const buildCodeFreeStep = (id: string, name: string) => ({+ id,+ name,+ type: 'CREATE_RECORD',+ valid: true,+ settings: {+ input: {+ objectName: 'company',+ objectRecord: { name: `${name} ${randomUUID()}` },+ },+ outputSchema: {},+ errorHandlingOptions: {+ retryOnFailure: { value: 0 },+ continueOnFailure: { value: false },+ },+ },+ nextStepIds: [],+});++const readCoreWorkflowRow = async (coreWorkflowId: string) => {+ const rows = await global.testDataSource.query(+ `SELECT id, "workspaceWorkflowId" FROM core."workflow" WHERE id = $1`,+ [coreWorkflowId],+ );++ return rows[0] as { id: string; workspaceWorkflowId: string | null };+};++const readCoreVersionRow = async (coreWorkflowVersionId: string) => {+ const rows = await global.testDataSource.query(+ `SELECT id, "workspaceWorkflowVersionId", steps, triggers, status+ FROM core."workflowVersion" WHERE id = $1`,+ [coreWorkflowVersionId],+ );++ return rows[0] as {+ id: string;+ workspaceWorkflowVersionId: string | null;+ steps: unknown[] | null;+ triggers: unknown[] | null;+ status: string;+ };+};++const readWorkspaceVersionRow = async (workspaceWorkflowVersionId: string) => {+ const rows = await global.testDataSource.query(+ `SELECT id, steps, trigger FROM "${TEST_WORKSPACE_SCHEMA}"."workflowVersion" WHERE id = $1`,+ [workspaceWorkflowVersionId],+ );++ return rows[0] as {+ id: string;+ steps: { id: string; name: string }[] | null;+ trigger: { type: string } | null;+ };+};++describe('workflow MCP tools on core identities (integration)', () => {+ const coreWorkflowIdsToDelete: string[] = [];++ afterAll(async () => {+ for (const coreWorkflowId of coreWorkflowIdsToDelete) {+ await callWorkflowTool('delete_workflow', { coreWorkflowId });+ }+ });++ describe('create → inspect → edit → validate → activate', () => {+ const iteratorStepId = randomUUID();+ const loopBodyStepId = randomUUID();+ const afterLoopStepId = randomUUID();+ const workflowName = `MCP core workflow ${randomUUID()}`;++ let coreWorkflowId: string;+ let coreWorkflowVersionId: string;++ it('should create a complete workflow and return core identifiers', async () => {+ const created = await callWorkflowTool<{+ success: boolean;+ result: { coreWorkflowId: string; coreWorkflowVersionId: string };+ }>('create_complete_workflow', {+ name: workflowName,+ trigger: buildManualTrigger(),+ steps: [+ buildIteratorStep(iteratorStepId),+ buildCodeFreeStep(loopBodyStepId, 'Inside loop'),+ buildCodeFreeStep(afterLoopStepId, 'After loop'),+ ],+ edges: [+ { source: TRIGGER_ID, target: iteratorStepId },+ {+ source: iteratorStepId,+ target: loopBodyStepId,+ sourceConnectionOptions: {+ connectedStepType: 'ITERATOR',+ settings: { isConnectedToLoop: true },+ },+ },+ { source: loopBodyStepId, target: iteratorStepId },+ { source: iteratorStepId, target: afterLoopStepId },+ ],+ });++ expect(created.success).toBe(true);++ coreWorkflowId = created.result.coreWorkflowId;+ coreWorkflowVersionId = created.result.coreWorkflowVersionId;++ coreWorkflowIdsToDelete.push(coreWorkflowId);++ expect(coreWorkflowId).toBeDefined();+ expect(coreWorkflowVersionId).toBeDefined();+ });++ it('should key the returned identifiers on core rows whose ids differ from the workspace mirrors', async () => {+ const coreWorkflow = await readCoreWorkflowRow(coreWorkflowId);+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);++ expect(coreWorkflow.workspaceWorkflowId).toBeDefined();+ expect(coreWorkflow.workspaceWorkflowId).not.toBe(coreWorkflowId);+ expect(coreVersion.workspaceWorkflowVersionId).toBeDefined();+ expect(coreVersion.workspaceWorkflowVersionId).not.toBe(+ coreWorkflowVersionId,+ );+ });++ it('should preserve the iterator loop connection and the step after the loop', async () => {+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);+ const steps = (coreVersion.steps ?? []) as {+ id: string;+ type: string;+ nextStepIds?: string[];+ settings?: { input?: { initialLoopStepIds?: string[] } };+ }[];++ const iteratorStep = steps.find((step) => step.id === iteratorStepId);+ const loopBodyStep = steps.find((step) => step.id === loopBodyStepId);++ expect(iteratorStep?.settings?.input?.initialLoopStepIds).toEqual([+ loopBodyStepId,+ ]);+ expect(iteratorStep?.nextStepIds).toEqual([afterLoopStepId]);+ expect(loopBodyStep?.nextStepIds).toEqual([iteratorStepId]);+ });++ it('should read the current version back by core workflow id', async () => {+ const current = await callWorkflowTool<{+ success: boolean;+ workflowVersion: {+ coreWorkflowVersionId: string;+ coreWorkflowId: string;+ steps: { id: string }[];+ };+ }>('get_workflow_current_version', { coreWorkflowId });++ expect(current.success).toBe(true);+ expect(current.workflowVersion.coreWorkflowVersionId).toBe(+ coreWorkflowVersionId,+ );+ expect(current.workflowVersion.coreWorkflowId).toBe(coreWorkflowId);+ expect(current.workflowVersion.steps.map(({ id }) => id)).toEqual(+ expect.arrayContaining([iteratorStepId, loopBodyStepId]),+ );+ });++ it('should list the workflow by its core id', async () => {+ const listed = await callWorkflowTool<{+ success: boolean;+ workflows: { coreWorkflowId: string; name: string }[];+ }>('list_workflows', { limit: 100 });++ expect(listed.success).toBe(true);+ expect(+ listed.workflows.some(+ (workflow) => workflow.coreWorkflowId === coreWorkflowId,+ ),+ ).toBe(true);+ });++ it('should list the workflow when filtering by status', async () => {+ const listed = await callWorkflowTool<{+ success: boolean;+ workflows: { coreWorkflowId: string }[];+ }>('list_workflows', { limit: 100, status: 'DRAFT' });++ expect(listed.success).toBe(true);+ expect(+ listed.workflows.some(+ (workflow) => workflow.coreWorkflowId === coreWorkflowId,+ ),+ ).toBe(true);+ });++ it('should list the workflow when no limit is passed', async () => {+ const listed = await callWorkflowTool<{+ success: boolean;+ workflows: { coreWorkflowId: string }[];+ }>('list_workflows', {});++ expect(listed.success).toBe(true);+ expect(listed.workflows.length).toBeGreaterThan(0);+ });++ it('should write an edit through the shared writer so the rollback mirror follows', async () => {+ const renamedStepName = `Renamed ${randomUUID()}`;+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);+ const stepToUpdate = (+ coreVersion.steps as { id: string; name: string }[]+ ).find((step) => step.id === loopBodyStepId);++ await callWorkflowTool('update_workflow_version_step', {+ coreWorkflowVersionId,+ step: { ...stepToUpdate, name: renamedStepName },+ });++ const updatedCoreVersion = await readCoreVersionRow(+ coreWorkflowVersionId,+ );+ const mirrorVersion = await readWorkspaceVersionRow(+ updatedCoreVersion.workspaceWorkflowVersionId as string,+ );++ expect(+ (updatedCoreVersion.steps as { id: string; name: string }[]).find(+ (step) => step.id === loopBodyStepId,+ )?.name,+ ).toBe(renamedStepName);+ expect(+ mirrorVersion.steps?.find((step) => step.id === loopBodyStepId)?.name,+ ).toBe(renamedStepName);+ });++ it('should read core content even after the workspace mirror content diverges', async () => {+ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);++ await global.testDataSource.query(+ `UPDATE "${TEST_WORKSPACE_SCHEMA}"."workflowVersion"+ SET steps = '[]'::jsonb WHERE id = $1`,+ [coreVersion.workspaceWorkflowVersionId],+ );++ const current = await callWorkflowTool<{+ success: boolean;+ workflowVersion: { steps: { id: string }[] };+ }>('get_workflow_current_version', { coreWorkflowId });++ expect(current.success).toBe(true);+ expect(current.workflowVersion.steps).toHaveLength(3);+ });++ it('should validate and activate using the core version id', async () => {+ const validated = await callWorkflowTool<{+ success: boolean;+ issues?: unknown[];+ }>('validate_workflow', { coreWorkflowVersionId });++ expect(validated).toMatchObject({ success: true });++ await callWorkflowTool('activate_workflow_version', {+ coreWorkflowVersionId,+ });++ const activatedCoreVersion = await readCoreVersionRow(+ coreWorkflowVersionId,+ );++ expect(activatedCoreVersion.status).toBe('ACTIVE');+ });++ it('should filter runs by core workflow id', async () => {+ const runs = await callWorkflowTool<{+ success: boolean;+ workflowRuns: { coreWorkflowId: string }[];+ }>('list_workflow_runs', { coreWorkflowId });++ expect(runs.success).toBe(true);+ expect(+ runs.workflowRuns.every((run) => run.coreWorkflowId === coreWorkflowId),+ ).toBe(true);+ });+ });++ describe('reads without a workspace definition mirror', () => {+ let coreWorkflowId: string;+ let coreWorkflowVersionId: string;++ beforeAll(async () => {+ const created = await callWorkflowTool<{+ result: { coreWorkflowId: string; coreWorkflowVersionId: string };+ }>('create_complete_workflow', {+ name: `Mirrorless core workflow ${randomUUID()}`,+ trigger: buildManualTrigger(),+ steps: [buildCodeFreeStep(randomUUID(), 'Only step')],+ edges: [],+ });++ coreWorkflowId = created.result.coreWorkflowId;+ coreWorkflowVersionId = created.result.coreWorkflowVersionId;+ coreWorkflowIdsToDelete.push(coreWorkflowId);++ const coreVersion = await readCoreVersionRow(coreWorkflowVersionId);+ const coreWorkflow = await readCoreWorkflowRow(coreWorkflowId);++ await global.testDataSource.query(+ `DELETE FROM "${TEST_WORKSPACE_SCHEMA}"."workflowVersion" WHERE id = $1`,+ [coreVersion.workspaceWorkflowVersionId],+ );+ await global.testDataSource.query(+ `DELETE FROM "${TEST_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,+ [coreWorkflow.workspaceWorkflowId],+ );+ });++ it('should still return the definition from core', async () => {+ const current = await callWorkflowTool<{+ success: boolean;+ workflowVersion: { coreWorkflowVersionId: string };+ }>('get_workflow_current_version', { coreWorkflowId });++ expect(current.success).toBe(true);+ expect(current.workflowVersion.coreWorkflowVersionId).toBe(+ coreWorkflowVersionId,+ );+ });++ it('should still list the workflow', async () => {+ const listed = await callWorkflowTool<{+ workflows: { coreWorkflowId: string }[];+ }>('list_workflows', { limit: 100 });++ expect(+ listed.workflows.some(+ (workflow) => workflow.coreWorkflowId === coreWorkflowId,+ ),+ ).toBe(true);+ });+ });++ describe('deletion', () => {+ it('should report a missing core workflow instead of reporting a deletion', async () => {+ const result = await callWorkflowTool<{+ success: boolean;+ error?: string;+ }>('delete_workflow', { coreWorkflowId: randomUUID() });++ expect(result.success).toBe(false);+ expect(result.error).toBe('Workflow not found');+ });++ it('should delete a workflow by its core id', async () => {+ const created = await callWorkflowTool<{+ result: { coreWorkflowId: string };+ }>('create_complete_workflow', {+ name: `Deletable core workflow ${randomUUID()}`,+ trigger: buildManualTrigger(),+ steps: [buildCodeFreeStep(randomUUID(), 'Only step')],+ edges: [],+ });++ const result = await callWorkflowTool<{+ success: boolean;+ coreWorkflowId: string;+ }>('delete_workflow', {+ coreWorkflowId: created.result.coreWorkflowId,+ });++ expect(result.success).toBe(true);++ const remaining = await global.testDataSource.query(+ `SELECT id FROM core."workflow" WHERE id = $1`,+ [created.result.coreWorkflowId],+ );++ expect(remaining).toHaveLength(0);+ });+ });+});diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-application-auth.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-application-auth.integration-spec.tsnew file mode 100644index 00000000000..d4e79faa563--- /dev/null+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-application-auth.integration-spec.ts@@ -0,0 +1,492 @@+import crypto from 'crypto';++import bcrypt from 'bcrypt';+import request from 'supertest';+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';+import { generateApplicationToken } from 'test/integration/metadata/suites/application/utils/generate-application-token.util';+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';+import { SystemPermissionFlag } from 'twenty-shared/constants';++import {+ SEED_APPLE_WORKSPACE_ID,+ SEED_YCOMBINATOR_WORKSPACE_ID,+} from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';++const APPLE_WORKSPACE_SCHEMA = 'workspace_1wgvd1injqtife6y4rvfbu3h5';++const baseUrl = `http://localhost:${APP_PORT}`;++type InstalledTestApplication = {+ applicationUniversalIdentifier: string;+ applicationId: string;+ accessToken: string;+};++const graphqlAs = (token: string, query: string, variables?: object) =>+ request(baseUrl)+ .post('/graphql')+ .set('Authorization', `Bearer ${token}`)+ .send({ query, variables });++const installApplicationWithoutUser = async ({+ name,+ grantsWorkflowsPermission,+}: {+ name: string;+ grantsWorkflowsPermission: boolean;+}): Promise<InstalledTestApplication> => {+ const applicationUniversalIdentifier = crypto.randomUUID();+ const roleUniversalIdentifier = crypto.randomUUID();++ await setupApplicationForSync({+ applicationUniversalIdentifier,+ name,+ description: name,+ sourcePath: name,+ });++ await syncApplication({+ manifest: buildBaseManifest({+ appId: applicationUniversalIdentifier,+ roleId: roleUniversalIdentifier,+ overrides: {+ roles: [+ {+ universalIdentifier: roleUniversalIdentifier,+ label: `${name} role`,+ description: 'Role used by the workflow application auth suite',+ canUpdateAllSettings: false,+ canReadAllObjectRecords: true,+ canUpdateAllObjectRecords: true,+ permissionFlagUniversalIdentifiers: grantsWorkflowsPermission+ ? [SystemPermissionFlag.WORKFLOWS]+ : [],+ },+ ],+ },+ }),+ });++ const [{ id: applicationId, applicationRegistrationId }] =+ await global.testDataSource.query(+ `SELECT id, "applicationRegistrationId" FROM core."application"+ WHERE "universalIdentifier" = $1 AND "workspaceId" = $2`,+ [applicationUniversalIdentifier, SEED_APPLE_WORKSPACE_ID],+ );++ const clientSecret = crypto.randomBytes(32).toString('hex');++ await global.testDataSource.query(+ `UPDATE core."applicationRegistration"+ SET "oAuthClientSecretHash" = $1, "oAuthScopes" = $2+ WHERE id = $3`,+ [+ await bcrypt.hash(clientSecret, 10),+ ['read', 'write'],+ applicationRegistrationId,+ ],+ );++ const [{ oAuthClientId }] = await global.testDataSource.query(+ `SELECT "oAuthClientId" FROM core."applicationRegistration" WHERE id = $1`,+ [applicationRegistrationId],+ );++ const tokenResponse = await request(baseUrl).post('/oauth/token').send({+ grant_type: 'client_credentials',+ client_id: oAuthClientId,+ client_secret: clientSecret,+ });++ if (tokenResponse.status !== 200) {+ throw new Error(+ `client_credentials grant failed (${tokenResponse.status}): ${JSON.stringify(tokenResponse.body)}`,+ );+ }++ return {+ applicationUniversalIdentifier,+ applicationId,+ accessToken: tokenResponse.body.access_token as string,+ };+};++const CREATE_CORE_WORKFLOW = `+ mutation CreateCoreWorkflow($input: CreateCoreWorkflowInput!) {+ createCoreWorkflow(input: $input) {+ id+ workspaceWorkflowId+ }+ }+`;++const CORE_WORKFLOW_VERSIONS = `+ query CoreWorkflowVersionsByCoreWorkflowId($coreWorkflowId: UUID!) {+ coreWorkflowVersionsByCoreWorkflowId(coreWorkflowId: $coreWorkflowId) {+ id+ status+ }+ }+`;++const CORE_WORKFLOW_BY_ID = `+ query CoreWorkflowById($coreWorkflowId: UUID!) {+ coreWorkflowById(coreWorkflowId: $coreWorkflowId) {+ id+ name+ }+ }+`;++const UPDATE_CORE_TRIGGER = `+ mutation UpdateCoreWorkflowVersionTrigger($input: UpdateCoreWorkflowVersionTriggerInput!) {+ updateCoreWorkflowVersionTrigger(input: $input) {+ trigger+ }+ }+`;++const MANUAL_TRIGGER = {+ name: 'Manual Trigger',+ type: 'MANUAL',+ settings: { outputSchema: {} },+ nextStepIds: [],+ position: { x: 0, y: 0 },+};++const APP_SCHEMA_INTROSPECTION = `+ query AppSchema {+ __schema {+ queryType {+ fields {+ name+ }+ }+ mutationType {+ fields {+ name+ }+ }+ }+ }+`;++const CORE_WORKFLOW_SEEDING_QUERY_FIELDS = [+ 'coreWorkflows',+ 'coreWorkflowVersionsByCoreWorkflowId',+];++const CORE_WORKFLOW_SEEDING_MUTATION_FIELDS = [+ 'createCoreWorkflow',+ 'createCoreWorkflowVersionStep',+ 'updateCoreWorkflowVersionStep',+ 'updateCoreWorkflowVersionTrigger',+ 'activateCoreWorkflowVersion',+];++describe('core workflow API with application credentials (integration)', () => {+ let authorizedApplication: InstalledTestApplication;+ let deniedApplication: InstalledTestApplication;++ const coreWorkflowIdsToDelete: string[] = [];++ beforeAll(async () => {+ authorizedApplication = await installApplicationWithoutUser({+ name: `Authorized workflow app ${crypto.randomUUID().slice(0, 8)}`,+ grantsWorkflowsPermission: true,+ });++ deniedApplication = await installApplicationWithoutUser({+ name: `Denied workflow app ${crypto.randomUUID().slice(0, 8)}`,+ grantsWorkflowsPermission: false,+ });+ });++ afterAll(async () => {+ if (coreWorkflowIdsToDelete.length > 0) {+ await graphqlAs(+ authorizedApplication.accessToken,+ `+ mutation DeleteCoreWorkflows($input: DeleteCoreWorkflowsInput!) {+ deleteCoreWorkflows(input: $input) {+ id+ }+ }+ `,+ { input: { coreWorkflowIds: coreWorkflowIdsToDelete } },+ );+ }++ await cleanupApplicationAndAppRegistration({+ applicationUniversalIdentifier:+ authorizedApplication.applicationUniversalIdentifier,+ });+ await cleanupApplicationAndAppRegistration({+ applicationUniversalIdentifier:+ deniedApplication.applicationUniversalIdentifier,+ });+ });++ it('should let an application without a human user create and configure a workflow', async () => {+ const createResponse = await graphqlAs(+ authorizedApplication.accessToken,+ CREATE_CORE_WORKFLOW,+ { input: { name: `App seeded workflow ${crypto.randomUUID()}` } },+ );++ expect(createResponse.body.errors).toBeUndefined();++ const coreWorkflowId = createResponse.body.data.createCoreWorkflow.id;++ coreWorkflowIdsToDelete.push(coreWorkflowId);++ const versionsResponse = await graphqlAs(+ authorizedApplication.accessToken,+ CORE_WORKFLOW_VERSIONS,+ { coreWorkflowId },+ );++ expect(versionsResponse.body.errors).toBeUndefined();++ const versions =+ versionsResponse.body.data.coreWorkflowVersionsByCoreWorkflowId;++ expect(versions).toHaveLength(1);+ expect(versions[0].status).toBe('DRAFT');++ const triggerResponse = await graphqlAs(+ authorizedApplication.accessToken,+ UPDATE_CORE_TRIGGER,+ {+ input: {+ coreWorkflowVersionId: versions[0].id,+ trigger: MANUAL_TRIGGER,+ },+ },+ );++ expect(triggerResponse.body.errors).toBeUndefined();+ });++ it('should attribute the created workflow to the application rather than to a workspace member', async () => {+ const createResponse = await graphqlAs(+ authorizedApplication.accessToken,+ CREATE_CORE_WORKFLOW,+ { input: { name: `App attributed workflow ${crypto.randomUUID()}` } },+ );++ expect(createResponse.body.errors).toBeUndefined();++ const { id: coreWorkflowId, workspaceWorkflowId } =+ createResponse.body.data.createCoreWorkflow;++ coreWorkflowIdsToDelete.push(coreWorkflowId);++ const [mirror] = await global.testDataSource.query(+ `SELECT "createdBySource", "createdByWorkspaceMemberId"+ FROM "${APPLE_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,+ [workspaceWorkflowId],+ );++ expect(mirror.createdBySource).toBe('APPLICATION');+ expect(mirror.createdByWorkspaceMemberId).toBeNull();+ });++ it('should attribute the workflow to the workspace member when a user creates it', async () => {+ const createResponse = await graphqlAs(+ APPLE_JANE_ADMIN_ACCESS_TOKEN,+ CREATE_CORE_WORKFLOW,+ { input: { name: `User created workflow ${crypto.randomUUID()}` } },+ );++ expect(createResponse.body.errors).toBeUndefined();++ const { id: coreWorkflowId, workspaceWorkflowId } =+ createResponse.body.data.createCoreWorkflow;++ coreWorkflowIdsToDelete.push(coreWorkflowId);++ const [mirror] = await global.testDataSource.query(+ `SELECT "createdBySource", "createdByWorkspaceMemberId", "createdByName"+ FROM "${APPLE_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,+ [workspaceWorkflowId],+ );++ expect(mirror.createdBySource).toBe('MANUAL');+ expect(mirror.createdByWorkspaceMemberId).not.toBeNull();+ });++ it('should keep the application role when a user acts through the application', async () => {+ const { data } = await generateApplicationToken({+ applicationId: authorizedApplication.applicationId,+ });++ const delegatedToken =+ data.generateApplicationToken.applicationAccessToken.token;++ const createResponse = await graphqlAs(+ delegatedToken,+ CREATE_CORE_WORKFLOW,+ { input: { name: `Delegated workflow ${crypto.randomUUID()}` } },+ );++ expect(createResponse.body.errors).toBeUndefined();++ const { id: coreWorkflowId, workspaceWorkflowId } =+ createResponse.body.data.createCoreWorkflow;++ coreWorkflowIdsToDelete.push(coreWorkflowId);++ const [mirror] = await global.testDataSource.query(+ `SELECT "createdBySource", "createdByWorkspaceMemberId"+ FROM "${APPLE_WORKSPACE_SCHEMA}"."workflow" WHERE id = $1`,+ [workspaceWorkflowId],+ );++ expect(mirror.createdBySource).toBe('MANUAL');+ expect(mirror.createdByWorkspaceMemberId).not.toBeNull();+ });++ it('should refuse an API key, which is neither a user nor an application', async () => {+ const response = await graphqlAs(+ API_KEY_ACCESS_TOKEN,+ CREATE_CORE_WORKFLOW,+ { input: { name: `Api key workflow ${crypto.randomUUID()}` } },+ );++ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');+ expect(response.body.data?.createCoreWorkflow).toBeFalsy();+ });++ it('should refuse an API key on a read, where no actor has to be resolved', async () => {+ const response = await graphqlAs(+ API_KEY_ACCESS_TOKEN,+ CORE_WORKFLOW_VERSIONS,+ {+ coreWorkflowId: crypto.randomUUID(),+ },+ );++ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');+ expect(+ response.body.data?.coreWorkflowVersionsByCoreWorkflowId,+ ).toBeFalsy();+ });++ it('should deny an application whose role does not grant the workflows permission', async () => {+ const response = await graphqlAs(+ deniedApplication.accessToken,+ CREATE_CORE_WORKFLOW,+ { input: { name: `Denied workflow ${crypto.randomUUID()}` } },+ );++ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');+ expect(response.body.data?.createCoreWorkflow).toBeFalsy();+ });++ it('should not expose a core workflow that belongs to another workspace', async () => {+ const otherWorkspaceCoreWorkflowId = crypto.randomUUID();++ const [{ id: otherWorkspaceApplicationId }] =+ await global.testDataSource.query(+ `SELECT id FROM core."application" WHERE "workspaceId" = $1 LIMIT 1`,+ [SEED_YCOMBINATOR_WORKSPACE_ID],+ );++ await global.testDataSource.query(+ `INSERT INTO core."workflow" (id, "workspaceId", name, "universalIdentifier", "applicationId")+ VALUES ($1, $2, 'Other workspace workflow', $3, $4)`,+ [+ otherWorkspaceCoreWorkflowId,+ SEED_YCOMBINATOR_WORKSPACE_ID,+ crypto.randomUUID(),+ otherWorkspaceApplicationId,+ ],+ );++ try {+ const response = await graphqlAs(+ authorizedApplication.accessToken,+ CORE_WORKFLOW_BY_ID,+ { coreWorkflowId: otherWorkspaceCoreWorkflowId },+ );++ expect(response.body.errors).toBeUndefined();+ expect(response.body.data?.coreWorkflowById).toBeNull();+ } finally {+ await global.testDataSource.query(+ `DELETE FROM core."workflow" WHERE id = $1`,+ [otherWorkspaceCoreWorkflowId],+ );+ }+ });++ it('should keep refusing an unauthenticated request', async () => {+ const response = await request(baseUrl)+ .post('/graphql')+ .send({+ query: CREATE_CORE_WORKFLOW,+ variables: { input: { name: 'Unauthenticated workflow' } },+ });++ expect(response.body.errors).toBeDefined();+ expect(response.body.data?.createCoreWorkflow).toBeFalsy();+ });++ it('should expose the core workflow operations the app SDK client seeds with', async () => {+ const response = await graphqlAs(+ authorizedApplication.accessToken,+ APP_SCHEMA_INTROSPECTION,+ );++ expect(response.body.errors).toBeUndefined();++ const queryFieldNames = (+ response.body.data?.__schema?.queryType?.fields ?? []+ ).map((field: { name: string }) => field.name);+ const mutationFieldNames = (+ response.body.data?.__schema?.mutationType?.fields ?? []+ ).map((field: { name: string }) => field.name);++ for (const fieldName of CORE_WORKFLOW_SEEDING_QUERY_FIELDS) {+ expect(queryFieldNames).toContain(fieldName);+ }++ for (const fieldName of CORE_WORKFLOW_SEEDING_MUTATION_FIELDS) {+ expect(mutationFieldNames).toContain(fieldName);+ }+ });++ it('should let the application read back a workflow it just created', async () => {+ const workflowName = `Seeded enrichment workflow ${crypto.randomUUID()}`;++ const createResponse = await graphqlAs(+ authorizedApplication.accessToken,+ CREATE_CORE_WORKFLOW,+ { input: { name: workflowName } },+ );++ expect(createResponse.body.errors).toBeUndefined();++ const createdCoreWorkflowId =+ createResponse.body.data?.createCoreWorkflow?.id;++ expect(createdCoreWorkflowId).toBeDefined();++ coreWorkflowIdsToDelete.push(createdCoreWorkflowId);++ const readResponse = await graphqlAs(+ authorizedApplication.accessToken,+ CORE_WORKFLOW_BY_ID,+ { coreWorkflowId: createdCoreWorkflowId },+ );++ expect(readResponse.body.errors).toBeUndefined();+ expect(readResponse.body.data?.coreWorkflowById?.id).toBe(+ createdCoreWorkflowId,+ );+ expect(readResponse.body.data?.coreWorkflowById?.name).toBe(workflowName);+ });+});diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.tsindex 31b629b3a8a..60b6475c9c3 100644--- a/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/workflow-ai-tool-malformed-validation.integration-spec.ts@@ -1,7 +1,6 @@import { randomUUID } from 'node:crypto';import request from 'supertest';-import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';const baseUrl = `http://localhost:${APP_PORT}`;@@ -73,18 +72,21 @@ const createCompleteWorkflow = (type ToolPayload = {success: boolean;error?: string;- result?: { workflowId?: string };+ result?: { coreWorkflowId?: string };};const parsePayload = (result: McpToolCallResult): ToolPayload =>JSON.parse(result.content?.[0]?.text ?? '{}') as ToolPayload;describe('Workflow AI tool validation (e2e)', () => {- const createdWorkflowIds: string[] = [];+ const createdCoreWorkflowIds: string[] = [];afterAll(async () => {- if (createdWorkflowIds.length > 0) {- await deleteRecordsByIds('workflow', createdWorkflowIds);+ for (const coreWorkflowId of createdCoreWorkflowIds) {+ await callMcpTool('execute_tool', {+ toolName: 'delete_workflow',+ arguments: { coreWorkflowId },+ });}});@@ -109,10 +111,10 @@ describe('Workflow AI tool validation (e2e)', () => {const payload = parsePayload(result);expect(payload.success).toBe(true);- expect(payload.result?.workflowId).toBeDefined();+ expect(payload.result?.coreWorkflowId).toBeDefined();- if (payload.result?.workflowId) {- createdWorkflowIds.push(payload.result.workflowId);+ if (payload.result?.coreWorkflowId) {+ createdCoreWorkflowIds.push(payload.result.coreWorkflowId);}});@@ -122,10 +124,10 @@ describe('Workflow AI tool validation (e2e)', () => {const payload = parsePayload(result);expect(payload.success).toBe(true);- expect(payload.result?.workflowId).toBeDefined();+ expect(payload.result?.coreWorkflowId).toBeDefined();- if (payload.result?.workflowId) {- createdWorkflowIds.push(payload.result.workflowId);+ if (payload.result?.coreWorkflowId) {+ createdCoreWorkflowIds.push(payload.result.coreWorkflowId);}});});