Add preconfigured Workflow creation agent (#13855)

Co-authored-by: Félix Malfait <felix.malfait@gmail.com> Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>
2025-08-27 17:50:38 +05:30
parent 28de78bfc0
commit 9098df7ddf
50 changed files with 1949 additions and 339 deletions
@@ -3,18 +3,26 @@ import { TypeOrmModule } from '@nestjs/typeorm';

 import { AiModule } from 'src/engine/core-modules/ai/ai.module';
 import { AgentEntity } from 'src/engine/metadata-modules/agent/agent.entity';
-import { AgentModule } from 'src/engine/metadata-modules/agent/agent.module';
+import { RoleTargetsEntity } from 'src/engine/metadata-modules/role/role-targets.entity';
+import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
+import { AiAgentExecutorService } from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/ai-agent-executor.service';

 import { AiAgentWorkflowAction } from './ai-agent.workflow-action';

@Module({
  imports: [
-    AgentModule,
    AiModule,
-    TypeOrmModule.forFeature([AgentEntity], 'core'),
+    TypeOrmModule.forFeature(
+      [AgentEntity, RoleTargetsEntity, RoleEntity],
+      'core',
+    ),
+  ],
+  providers: [
+    ScopedWorkspaceContextFactory,
+    AiAgentWorkflowAction,
+    AiAgentExecutorService,
  ],
-  providers: [ScopedWorkspaceContextFactory, AiAgentWorkflowAction],
  exports: [AiAgentWorkflowAction],
 })
 export class AiAgentActionModule {}
@@ -1,13 +1,12 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';

-import { Repository } from 'typeorm';
 import { resolveInput } from 'twenty-shared/utils';
+import { Repository } from 'typeorm';

 import { type WorkflowAction } from 'src/modules/workflow/workflow-executor/interfaces/workflow-action.interface';

 import { AIBillingService } from 'src/engine/core-modules/ai/services/ai-billing.service';
-import { AgentExecutionService } from 'src/engine/metadata-modules/agent/agent-execution.service';
 import { AgentEntity } from 'src/engine/metadata-modules/agent/agent.entity';
 import {
  AgentException,
@@ -19,13 +18,14 @@ import {
 } from 'src/modules/workflow/workflow-executor/exceptions/workflow-step-executor.exception';
 import { type WorkflowActionInput } from 'src/modules/workflow/workflow-executor/types/workflow-action-input';
 import { type WorkflowActionOutput } from 'src/modules/workflow/workflow-executor/types/workflow-action-output.type';
+import { AiAgentExecutorService } from 'src/modules/workflow/workflow-executor/workflow-actions/ai-agent/services/ai-agent-executor.service';

 import { isWorkflowAiAgentAction } from './guards/is-workflow-ai-agent-action.guard';

@Injectable()
 export class AiAgentWorkflowAction implements WorkflowAction {
  constructor(
-    private readonly agentExecutionService: AgentExecutionService,
+    private readonly aiAgentExecutionService: AiAgentExecutorService,
    private readonly aiBillingService: AIBillingService,
    @InjectRepository(AgentEntity, 'core')
    private readonly agentRepository: Repository<AgentEntity>,
@@ -74,12 +74,13 @@ export class AiAgentWorkflowAction implements WorkflowAction {
        );
      }

-      const { result, usage } = await this.agentExecutionService.executeAgent({
-        agent,
-        context,
-        schema: step.settings.outputSchema,
-        userPrompt: resolveInput(prompt, context) as string,
-      });
+      const { result, usage } = await this.aiAgentExecutionService.executeAgent(
+        {
+          agent,
+          schema: step.settings.outputSchema,
+          userPrompt: resolveInput(prompt, context) as string,
+        },
+      );

      await this.aiBillingService.calculateAndBillUsage(
        agent?.modelId ?? 'auto',
@@ -0,0 +1,145 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { generateObject, generateText, ToolSet } from 'ai';
+import { Repository } from 'typeorm';
+
+import { AiModelRegistryService } from 'src/engine/core-modules/ai/services/ai-model-registry.service';
+import { ToolAdapterService } from 'src/engine/core-modules/ai/services/tool-adapter.service';
+import { ToolService } from 'src/engine/core-modules/ai/services/tool.service';
+import { AgentExecutionResult } from 'src/engine/metadata-modules/agent/agent-execution.service';
+import { AgentEntity } from 'src/engine/metadata-modules/agent/agent.entity';
+import {
+  AgentException,
+  AgentExceptionCode,
+} from 'src/engine/metadata-modules/agent/agent.exception';
+import { AGENT_CONFIG } from 'src/engine/metadata-modules/agent/constants/agent-config.const';
+import { AGENT_SYSTEM_PROMPTS } from 'src/engine/metadata-modules/agent/constants/agent-system-prompts.const';
+import { convertOutputSchemaToZod } from 'src/engine/metadata-modules/agent/utils/convert-output-schema-to-zod';
+import { RoleTargetsEntity } from 'src/engine/metadata-modules/role/role-targets.entity';
+import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { OutputSchema } from 'src/modules/workflow/workflow-builder/workflow-schema/types/output-schema.type';
+
+@Injectable()
+export class AiAgentExecutorService {
+  private readonly logger = new Logger(AiAgentExecutorService.name);
+  constructor(
+    private readonly aiModelRegistryService: AiModelRegistryService,
+    private readonly toolAdapterService: ToolAdapterService,
+    @InjectRepository(RoleTargetsEntity, 'core')
+    private readonly roleTargetsRepository: Repository<RoleTargetsEntity>,
+    @InjectRepository(RoleEntity, 'core')
+    private readonly roleRepository: Repository<RoleEntity>,
+    private readonly toolService: ToolService,
+  ) {}
+
+  private async getTools(
+    agentId: string,
+    workspaceId: string,
+  ): Promise<ToolSet> {
+    const roleTarget = await this.roleTargetsRepository.findOne({
+      where: {
+        agentId: agentId,
+        workspaceId,
+      },
+      select: ['roleId'],
+    });
+
+    const role = await this.roleRepository.findOne({
+      where: {
+        id: roleTarget?.roleId,
+        workspaceId,
+      },
+    });
+
+    if (!roleTarget?.roleId || !role) {
+      const actionTools = await this.toolAdapterService.getTools();
+
+      return { ...actionTools };
+    }
+
+    const actionTools = await this.toolAdapterService.getTools(
+      role.id,
+      workspaceId,
+    );
+
+    const databaseTools = await this.toolService.listTools(
+      role.id,
+      workspaceId,
+    );
+
+    return {
+      ...databaseTools,
+      ...actionTools,
+    };
+  }
+
+  async executeAgent({
+    agent,
+    schema,
+    userPrompt,
+  }: {
+    agent: AgentEntity | null;
+    schema: OutputSchema;
+    userPrompt: string;
+  }): Promise<AgentExecutionResult> {
+    try {
+      const registeredModel =
+        await this.aiModelRegistryService.resolveModelForAgent(agent);
+
+      const tools = agent
+        ? await this.getTools(agent.id, agent.workspaceId)
+        : {};
+
+      this.logger.log(`Generated ${Object.keys(tools).length} tools for agent`);
+
+      const textResponse = await generateText({
+        system: `You are executing as part of a workflow automation. ${agent ? agent.prompt : ''}`,
+        tools,
+        model: registeredModel.model,
+        prompt: userPrompt,
+        maxSteps: AGENT_CONFIG.MAX_STEPS,
+      });
+
+      if (Object.keys(schema).length === 0) {
+        return {
+          result: { response: textResponse.text },
+          usage: textResponse.usage,
+        };
+      }
+      const output = await generateObject({
+        system: AGENT_SYSTEM_PROMPTS.OUTPUT_GENERATOR,
+        model: registeredModel.model,
+        prompt: `Based on the following execution results, generate the structured output according to the schema:
+
+                 Execution Results: ${textResponse.text}
+
+                 Please generate the structured output based on the execution results and context above.`,
+        schema: convertOutputSchemaToZod(schema),
+      });
+
+      return {
+        result: output.object,
+        usage: {
+          promptTokens:
+            (textResponse.usage?.promptTokens ?? 0) +
+            (output.usage?.promptTokens ?? 0),
+          completionTokens:
+            (textResponse.usage?.completionTokens ?? 0) +
+            (output.usage?.completionTokens ?? 0),
+          totalTokens:
+            (textResponse.usage?.totalTokens ?? 0) +
+            (output.usage?.totalTokens ?? 0),
+        },
+      };
+    } catch (error) {
+      if (error instanceof AgentException) {
+        throw error;
+      }
+      throw new AgentException(
+        error instanceof Error ? error.message : 'Agent execution failed',
+        AgentExceptionCode.AGENT_EXECUTION_FAILED,
+      );
+    }
+  }
+}