@autobe/agent 0.15.1 → 0.16.0

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -1,13 +1,17 @@
 import {
   AutoBeAssistantMessageHistory,
+  AutoBeOpenApi,
   AutoBeRealizeAuthorization,
+  AutoBeRealizeFunction,
   AutoBeRealizeHistory,
+  IAutoBeCompiler,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { getAutoBeGenerated } from "../../factory/getAutoBeGenerated";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { writeCodeUntilCompilePassed } from "./writeCodeUntilCompilePassed";
 
@@ -16,12 +20,13 @@ export const orchestrateRealize =
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
-    props;
-    const ops = ctx.state().interface?.document.operations;
-    if (!ops) {
+    const operations: AutoBeOpenApi.IOperation[] | undefined =
+      ctx.state().interface?.document.operations;
+    if (!operations) {
       throw new Error("Can't do realize agent because operations are nothing.");
     }
 
+    const start: Date = new Date();
     ctx.dispatch({
       type: "realizeStart",
       created_at: new Date().toISOString(),
@@ -29,71 +34,61 @@ export const orchestrateRealize =
       step: ctx.state().test?.step ?? 0,
     });
 
+    // generate authorizations and functions
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
-    const files = await writeCodeUntilCompilePassed(
-      ctx,
-      ops,
+    const result = await writeCodeUntilCompilePassed(ctx)({
+      operations,
       authorizations,
-      3,
-    );
-
-    const now = new Date().toISOString();
-    const realize = ctx.state().realize;
-    if (realize !== null) {
-      realize.functions = files;
-    } else {
-      const history = (ctx.state().realize = {
-        type: "realize",
-        compiled: {
-          type: "success",
-        },
-        functions: {
-          ...files,
-          ...authorizations
-            .flatMap((el) => {
-              return [
-                {
-                  [el.decorator.location]: el.decorator.content,
-                },
-                {
-                  [el.payload.location]: el.payload.content,
-                },
-                {
-                  [el.payload.location]: el.payload.content,
-                },
-              ];
-            })
-            .reduce((acc, cur) => Object.assign(acc, cur)),
-        },
-        completed_at: now,
-        created_at: now,
-        id: v4(),
-        reason: props.reason,
-        step: ctx.state().analyze?.step ?? 0,
-        authorizations: ctx.state().realize?.authorizations ?? [],
-      } satisfies AutoBeRealizeHistory);
+      retry: 4,
+    });
 
-      ctx.histories().push(history);
-    }
+    const functions: AutoBeRealizeFunction[] = result.functions;
 
-    ctx.dispatch({
-      type: "assistantMessage",
-      text: "Any codes can not be generated.",
-      created_at: now,
-    });
+    // compile controllers
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const controllers: Record<string, string> =
+      await compiler.realize.controller({
+        document: ctx.state().interface!.document,
+        functions,
+        authorizations,
+      });
 
-    return {
+    const history: AutoBeRealizeHistory = {
       type: "realize",
-      compiled: {
-        type: "success",
-      },
-      functions: files,
-      completed_at: now,
-      created_at: now,
+      compiled: result.compiled,
+      authorizations,
+      functions,
+      controllers,
+      completed_at: new Date().toISOString(),
+      created_at: start.toISOString(),
       id: v4(),
       reason: props.reason,
       step: ctx.state().analyze?.step ?? 0,
-      authorizations: ctx.state().realize?.authorizations ?? [],
     };
+
+    // report
+    ctx.dispatch({
+      type: "realizeComplete",
+      created_at: new Date().toISOString(),
+      functions: history.functions,
+      authorizations: history.authorizations,
+      controllers: history.controllers,
+      compiled: await compiler.typescript.compile({
+        files: await getAutoBeGenerated(
+          compiler,
+          {
+            ...ctx.state(),
+            realize: history,
+          },
+          [...ctx.histories(), history],
+          ctx.usage(),
+        ),
+      }),
+      step: ctx.state().analyze?.step ?? 0,
+    });
+    ctx.state().realize = history;
+    ctx.histories().push(history);
+
+    return history;
   };

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -1,9 +1,5 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import {
-  AutoBeRealizeAuthorization,
-  IAutoBeCompiler,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
+import { AutoBeRealizeAuthorization, IAutoBeCompiler } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -14,7 +10,6 @@ import { enforceToolCall } from "../../utils/enforceToolCall";
 import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
 import { IAutoBeRealizeAuthorizationApplication } from "./structures/IAutoBeRealizeAuthorizationApplication";
 import { transformRealizeAuthorizationHistories } from "./transformRealizeAuthorization";
-import { transformRealizeAuthorizationCorrectHistories } from "./transformRealizeAuthorizationCorrectHistories";
 import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
 import { InternalFileSystem } from "./utils/InternalFileSystem";
 
@@ -27,11 +22,7 @@ import { InternalFileSystem } from "./utils/InternalFileSystem";
 export async function orchestrateRealizeAuthorization<
   Model extends ILlmSchema.Model,
 >(ctx: AutoBeContext<Model>): Promise<AutoBeRealizeAuthorization[]> {
-  const roles =
-    ctx
-      .state()
-      .interface?.document.components.authorization?.map((auth) => auth.name) ??
-    [];
+  const roles = ctx.state().analyze?.roles.map((role) => role.name) ?? [];
 
   let completed = 0;
 
@@ -109,6 +100,7 @@ async function process<Model extends ILlmSchema.Model>(
     });
   if (pointer.value === null) throw new Error("Failed to create decorator.");
 
+  const compiler: IAutoBeCompiler = await ctx.compiler();
   const authorization: AutoBeRealizeAuthorization = {
     role,
     decorator: {
@@ -121,7 +113,9 @@ async function process<Model extends ILlmSchema.Model>(
     payload: {
       location: AuthorizationFileSystem.payloadPath(pointer.value.payload.name),
       name: pointer.value.payload.name,
-      content: pointer.value.payload.content,
+      content: await compiler.typescript.beautify(
+        pointer.value.payload.content,
+      ),
     },
     provider: {
       location: AuthorizationFileSystem.providerPath(
@@ -135,114 +129,12 @@ async function process<Model extends ILlmSchema.Model>(
   const prismaClients: Record<string, string> =
     compiled?.type === "success" ? compiled.nodeModules : {};
 
-  return correctDecorator(ctx, authorization, prismaClients, templateFiles);
-}
-
-async function correctDecorator<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  auth: AutoBeRealizeAuthorization,
-  prismaClients: Record<string, string>,
-  templateFiles: Record<string, string>,
-  life: number = 4,
-): Promise<AutoBeRealizeAuthorization> {
-  // Check Compile
-  const files = {
-    ...templateFiles,
-    ...prismaClients,
-    [auth.decorator.location]: auth.decorator.content,
-    [auth.payload.location]: auth.payload.content,
-    [auth.provider.location]: auth.provider.content,
-  };
-
-  const compiler: IAutoBeCompiler = await ctx.compiler();
-  const result: IAutoBeTypeScriptCompileResult =
-    await compiler.typescript.compile({
-      files,
-    });
-  ctx.dispatch({
-    type: "realizeAuthorizationValidate",
-    created_at: new Date().toISOString(),
-    result,
-    authorization: auth,
-    step: ctx.state().test?.step ?? 0,
-  });
-  if (result.type === "success") {
-    return auth;
-  } else if (result.type === "exception" || life === 0) {
-    return auth;
-  }
-
-  const pointer: IPointer<IAutoBeRealizeAuthorizationApplication.IProps | null> =
-    {
-      value: null,
-    };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-    },
-    histories: transformRealizeAuthorizationCorrectHistories(
-      ctx,
-      auth,
-      templateFiles,
-      result.diagnostics,
-    ),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  await agentica
-    .conversate("Please correct the decorator and the provider.")
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
-      ctx.usage().record(tokenUsage, ["realize"]);
-    });
-
-  if (pointer.value === null) throw new Error("Failed to correct decorator.");
-
-  const corrected: AutoBeRealizeAuthorization = {
-    role: auth.role,
-    decorator: {
-      location: auth.decorator.location,
-      name: pointer.value.decorator.name,
-      content: pointer.value.decorator.content,
-    },
-    payload: {
-      location: auth.payload.location,
-      name: pointer.value.payload.name,
-      content: pointer.value.payload.content,
-    },
-    provider: {
-      location: auth.provider.location,
-      name: pointer.value.provider.name,
-      content: pointer.value.provider.content,
-    },
-  };
-
-  const res: AutoBeRealizeAuthorization =
-    await orchestrateRealizeAuthorizationCorrect(
-      ctx,
-      corrected,
-      prismaClients,
-      templateFiles,
-      life - 1,
-    );
-
-  return {
-    ...res,
-    role: auth.role,
-  };
+  return orchestrateRealizeAuthorizationCorrect(
+    ctx,
+    authorization,
+    prismaClients,
+    templateFiles,
+  );
 }
 
 function createApplication<Model extends ILlmSchema.Model>(props: {

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -15,6 +15,7 @@ import { enforceToolCall } from "../../utils/enforceToolCall";
 import { IAutoBeRealizeAuthorizationCorrectApplication } from "./structures/IAutoBeRealizeAuthorizationCorrectApplication";
 import { transformRealizeAuthorizationCorrectHistories } from "./transformRealizeAuthorizationCorrectHistories";
 import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
+import { AutoBeRealizeAuthorizationReplaceImport } from "./utils/AutoBeRealizeAuthorizationReplaceImport";
 
 export async function orchestrateRealizeAuthorizationCorrect<
   Model extends ILlmSchema.Model,
@@ -25,20 +26,32 @@ export async function orchestrateRealizeAuthorizationCorrect<
   templateFiles: Record<string, string>,
   life: number = 4,
 ): Promise<AutoBeRealizeAuthorization> {
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  const providerContent: string = await compiler.typescript.beautify(
+    AutoBeRealizeAuthorizationReplaceImport.replaceProviderImport(
+      authorization.role,
+      authorization.provider.content,
+    ),
+  );
+  const decoratorContent: string = await compiler.typescript.beautify(
+    AutoBeRealizeAuthorizationReplaceImport.replaceDecoratorImport(
+      authorization.role,
+      authorization.decorator.content,
+    ),
+  );
+
   // Check Compile
   const files: Record<string, string> = {
     ...templateFiles,
     ...prismaClients,
     [AuthorizationFileSystem.decoratorPath(authorization.decorator.name)]:
-      authorization.decorator.content,
+      decoratorContent,
     [AuthorizationFileSystem.providerPath(authorization.provider.name)]:
-      authorization.provider.content,
+      providerContent,
     [AuthorizationFileSystem.payloadPath(authorization.payload.name)]:
       authorization.payload.content,
   };
 
-  const compiler: IAutoBeCompiler = await ctx.compiler();
-
   const compiled: IAutoBeTypeScriptCompileResult =
     await compiler.typescript.compile({
       files,
@@ -113,8 +126,11 @@ export async function orchestrateRealizeAuthorizationCorrect<
       ),
     },
     payload: {
-      ...pointer.value.payload,
+      name: pointer.value.payload.name,
       location: AuthorizationFileSystem.payloadPath(pointer.value.payload.name),
+      content: await compiler.typescript.beautify(
+        pointer.value.payload.content,
+      ),
     },
     role: authorization.role,
   };

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -1,6 +1,7 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import {
   AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
@@ -15,6 +16,7 @@ import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifac
 import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
 import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
 import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
 import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
 import { transformRealizeCoderHistories } from "./transformRealizeCoderHistories";
 import { RealizeFileSystem } from "./utils/ProviderFileSystem";
@@ -41,17 +43,13 @@ import { replaceImportStatements } from "./utils/replaceImportStatements";
 export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operation: AutoBeOpenApi.IOperation,
+  previousCodes: IAutoBeRealizeCompile.Success[],
   props: RealizePlannerOutput,
   previous: string | null,
   total: IAutoBeTypeScriptCompileResult.IDiagnostic[],
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-): Promise<
-  | Pick<
-      IAutoBeRealizeCoderApplication.RealizeCoderOutput,
-      "filename" | "implementationCode"
-    >
-  | FAILED
-> => {
+  authorization?: AutoBeRealizeAuthorization,
+): Promise<IAutoBeRealizeCoderApplication.RealizeCoderOutput | FAILED> => {
   total;
 
   const artifacts: IAutoBeTestScenarioArtifacts =
@@ -63,9 +61,9 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
       dependencies: [],
     });
 
-  const pointer: IPointer<Pick<
+  const pointer: IPointer<Omit<
     IAutoBeRealizeCoderApplication.RealizeCoderOutput,
-    "implementationCode"
+    "filename"
   > | null> = {
     value: null,
   };
@@ -89,10 +87,12 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
     },
     histories: transformRealizeCoderHistories(
       ctx.state(),
+      previousCodes,
       props,
       artifacts,
       previous,
       diagnostics,
+      authorization,
     ),
   });
   enforceToolCall(agent);
@@ -123,6 +123,7 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
   }
 
   pointer.value.implementationCode = await replaceImportStatements(ctx)(
+    artifacts,
     pointer.value.implementationCode,
     props.decoratorEvent?.payload.name,
   );

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationApplication.ts

@@ -42,13 +42,12 @@ export namespace IAutoBeRealizeAuthorizationApplication {
     name: string;
 
     /**
-     * Complete TypeScript code for the authentication Provider function and its
-     * corresponding Payload interface. Must include: JWT token verification
-     * using jwtAuthorize function, role type checking against payload.type,
-     * database query using MyGlobal.prisma.{tableName} pattern to verify user
-     * existence, proper error handling with ForbiddenException and
-     * UnauthorizedException, and the Payload interface definition with id (UUID
-     * format) and type (role discriminator) fields using typia tags.
+     * Complete TypeScript code for the authentication Provider function. Must
+     * include: JWT token verification using jwtAuthorize function, role type
+     * checking against payload.type, database query using
+     * MyGlobal.prisma.{tableName} pattern to verify user existence, and proper
+     * error handling with ForbiddenException and UnauthorizedException. The
+     * function should return the authenticated user payload data.
      */
     content: string;
   }
@@ -76,19 +75,20 @@ export namespace IAutoBeRealizeAuthorizationApplication {
 
   export interface IPayloadType {
     /**
-     * The name of the Decorator to be generated in {Role}Auth format (e.g.,
-     * AdminAuth, UserAuth). This decorator will be used as a parameter
-     * decorator in Controller methods to automatically authenticate and
-     * authorize users for the specific role, injecting the authenticated user
-     * payload as a method parameter.
+     * The name of the Payload type to be generated in {Role}Payload format
+     * (e.g., AdminPayload, UserPayload). This type defines the structure of the
+     * authenticated user data that will be injected into Controller methods
+     * when using the decorator.
      */
     name: string;
 
     /**
-     * The TypeScript code for the Payload type in {Role}Payload format (e.g.,
-     * AdminPayload, UserPayload). This interface defines the structure of the
+     * Complete TypeScript code for the Payload type interface in {Role}Payload
+     * format (e.g., AdminPayload, UserPayload). Must include: id field with
+     * UUID format validation, type field as role discriminator, and proper
+     * typia tags for validation. This interface defines the structure of the
      * authenticated user data that will be injected into Controller methods
-     * when using the decorator. It serves as the TypeScript type for the
+     * when using the decorator and serves as the TypeScript type for the
      * parameter in Controller method signatures.
      */
     content: string;

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationCorrectApplication.ts

@@ -12,29 +12,22 @@ export namespace IAutoBeRealizeAuthorizationCorrectApplication {
     /**
      * Step 1: TypeScript compilation error analysis and diagnosis.
      *
-     * AI identifies all compilation errors (type mismatches, imports, syntax)
-     * and categorizes them by component (providers/decorator/payload). Analyzes
-     * error dependencies and determines fix priorities for systematic
-     * resolution.
+     * AI identifies and categorizes all compilation errors (type mismatches,
+     * import issues, syntax errors) by component (providers/decorator/payload).
+     * Lists specific error messages with their locations and types for
+     * systematic troubleshooting.
      */
     error_analysis: string;
 
     /**
-     * Step 2: Corrected implementation with all compilation errors resolved.
+     * Step 2: Solution guidance and fix recommendations.
      *
-     * AI generates fixed versions of provider, decorator, and payload code.
-     * Maintains original functionality while ensuring TypeScript compilation
-     * success and proper NestJS/Prisma framework integration.
+     * AI provides clear, actionable instructions on how to resolve each
+     * identified error. Includes specific steps like "add property X to
+     * interface Y", "update import path from A to B", or "change type from C to
+     * D". Focus on guidance rather than generating complete code
+     * implementations.
      */
-    corrected_implementation: string;
-
-    /**
-     * Step 3: Final validation and comprehensive fix summary.
-     *
-     * AI validates corrected code compiles successfully and documents all
-     * changes made. Provides production-ready code with detailed change log for
-     * maintenance reference.
-     */
-    validation_summary: string;
+    solution_guidance: string;
   }
 }

package/src/orchestrate/realize/structures/IAutoBeRealizeCoderApplication.ts

@@ -16,7 +16,7 @@ export namespace IAutoBeRealizeCoderApplication {
      * The detailed output of the code generation process, containing all phases
      * from planning to final implementation of a TypeScript provider function.
      */
-    output: RealizeCoderOutput;
+    output: Omit<IAutoBeRealizeCoderApplication.RealizeCoderOutput, "filename">;
   }
 
   /**
@@ -287,8 +287,10 @@ export namespace IAutoBeRealizeCoderApplication {
      * - Resolve all TypeScript errors without using `as any`.
      * - Provide safe brand casting only if required (e.g., `as string &
      *   tags.Format<'uuid'>`).
+     * - If no TypeScript errors exist, this field MUST contain the text: "No
+     *   TypeScript errors detected - skipping this phase"
      */
-    withCompilerFeedback?: string;
+    withCompilerFeedback: string;
 
     /**
      * Step 5.

package/src/orchestrate/realize/structures/IAutoBeRealizeCompile.ts

@@ -4,48 +4,55 @@ import {
 } from "@autobe/interface";
 import { tags } from "typia";
 
+import { IAutoBeRealizeCoderApplication } from "./IAutoBeRealizeCoderApplication";
 import { FAILED } from "./IAutoBeRealizeFailedSymbol";
 
 export namespace IAutoBeRealizeCompile {
+  export type Result =
+    | IAutoBeRealizeCompile.Success
+    | IAutoBeRealizeCompile.Fail;
+
   type IBase<T extends "success" | "failed"> = {
+    /**
+     * Indicates whether code generation was attempted. "success" means code was
+     * generated, but compilation may still fail. "failed" means code generation
+     * was not possible (e.g., invalid input).
+     */
     type: T;
   };
 
-  interface IOperation {
+  export interface Success extends IBase<"success"> {
     /**
      * Operation: An object containing the function specification including the
      * endpoint
      */
-    op: AutoBeOpenApi.IOperation;
-  }
+    operation: AutoBeOpenApi.IOperation;
 
-  interface SuccessResult {
-    /** The name of the file where the implementation will be written */
-    filename: string;
-    /** The generated implementation code for the function */
-    implementationCode: string;
-    /** Function name */
-    name: string;
+    /** Result */
+    result: IAutoBeRealizeCoderApplication.RealizeCoderOutput;
   }
 
-  export interface Success extends IBase<"success">, IOperation {
-    result: SuccessResult;
-  }
+  export interface Fail extends IBase<"failed"> {
+    /**
+     * Operation: An object containing the function specification including the
+     * endpoint
+     */
+    operation: AutoBeOpenApi.IOperation;
 
-  export interface Fail extends IBase<"failed">, IOperation {
+    /** Result */
     result: FAILED;
   }
 
-  export interface FileContentMapEntry {
+  export interface CodeArtifact {
     result: "failed" | "success";
     content: string;
     role?: (string & tags.MinLength<1>) | null;
     endpoint?: AutoBeOpenApi.IEndpoint;
-    location?: string;
+    location: string;
     name?: string;
   }
 
-  export type FileContentMap = Record<string, FileContentMapEntry>;
+  export type FileContentMap = Record<string, CodeArtifact>;
 
   export interface CompileDiagnostics {
     /**

package/src/orchestrate/realize/transformRealizeAuthorization.ts

@@ -4,7 +4,6 @@ import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
 
 export const transformRealizeAuthorizationHistories = (
   ctx: AutoBeContext<ILlmSchema.Model>,
@@ -32,16 +31,13 @@ export const transformRealizeAuthorizationHistories = (
         "",
         JSON.stringify(ctx.state().prisma?.schemas, null, 2),
         "",
-        "## File Structure Example",
+        "## Component Naming Convention",
         "",
-        "Please refer to the following file structure to construct appropriate import paths:",
-        "",
-        "File locations:",
-        "",
-        `- Decorator Path : ${AuthorizationFileSystem.decoratorPath("AdminAuth.ts")}`,
-        `- Payload Path : ${AuthorizationFileSystem.payloadPath("AdminPayload.ts")}`,
-        `- Provider Path : ${AuthorizationFileSystem.providerPath("adminAuthorize.ts")}`,
+        "Please follow this naming convention for the authorization components:",
         "",
+        `- Provider Name: ${role}Authorize (e.g. ${role}Authorize)`,
+        `- Decorator Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Auth (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Auth)`,
+        `- Payload Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Payload (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Payload)`,
       ].join("\n"),
     },
   ];