@autobe/agent 0.18.0 → 0.20.0

package/src/orchestrate/interface/orchestrateInterfaceAuthorizations.ts

@@ -1,42 +1,56 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeAnalyzeRole, AutoBeOpenApi } from "@autobe/interface";
+import {
+  AutoBeAnalyzeRole,
+  AutoBeInterfaceAuthorization,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
 import { AutoBeInterfaceAuthorizationEvent } from "@autobe/interface/src/events/AutoBeInterfaceAuthorizationEvent";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { StringUtil } from "@autobe/utils";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { IProgress } from "../internal/IProgress";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceAuthorizationsHistories } from "./histories/transformInterfaceAuthorizationsHistories";
 import { IAutoBeInterfaceAuthorizationsApplication } from "./structures/IAutoBeInterfaceAuthorizationsApplication";
 
 export async function orchestrateInterfaceAuthorizations<
   Model extends ILlmSchema.Model,
->(ctx: AutoBeContext<Model>): Promise<AutoBeOpenApi.IOperation[]> {
+>(ctx: AutoBeContext<Model>): Promise<AutoBeInterfaceAuthorization[]> {
   const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: roles.length,
     completed: 0,
   };
-  const operations: AutoBeOpenApi.IOperation[][] = await Promise.all(
-    roles.map(async (role) => {
-      const event: AutoBeInterfaceAuthorizationEvent = await process(
-        ctx,
-        role,
-        progress,
-      );
-      ctx.dispatch(event);
-      return event.operations;
-    }),
-  );
-  return operations.flat();
+  const authorizations: AutoBeInterfaceAuthorization[] =
+    await executeCachedBatch(
+      roles.map((role) => async (promptCacheKey) => {
+        const event: AutoBeInterfaceAuthorizationEvent = await process(
+          ctx,
+          role,
+          progress,
+          promptCacheKey,
+        );
+        ctx.dispatch(event);
+        return {
+          role: role.name,
+          operations: event.operations,
+        };
+      }),
+    );
+
+  return authorizations;
 }
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   role: AutoBeAnalyzeRole,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
+  promptCacheKey: string,
 ): Promise<AutoBeInterfaceAuthorizationEvent> {
   const pointer: IPointer<IAutoBeInterfaceAuthorizationsApplication.IProps | null> =
     {
@@ -47,11 +61,13 @@ async function process<Model extends ILlmSchema.Model>(
     histories: transformInterfaceAuthorizationsHistories(ctx.state(), role),
     controller: createController({
       model: ctx.model,
+      role: role.name,
       build: (next) => {
         pointer.value = next;
       },
     }),
     enforceFunctionCall: true,
+    promptCacheKey,
     message: "Create Authorization Operation for the given roles",
   });
   if (pointer.value === null)
@@ -59,6 +75,7 @@ async function process<Model extends ILlmSchema.Model>(
 
   return {
     type: "interfaceAuthorization",
+    id: v7(),
     operations: pointer.value.operations,
     completed: ++progress.completed,
     tokenUsage,
@@ -70,13 +87,100 @@ async function process<Model extends ILlmSchema.Model>(
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  role: string;
   build: (next: IAutoBeInterfaceAuthorizationsApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps> =
+      typia.validate<IAutoBeInterfaceAuthorizationsApplication.IProps>(next);
+    if (result.success === false) return result;
+
+    const errors: IValidation.IError[] = [];
+    result.data.operations.forEach((op, i) => {
+      // validate authorizationRole
+      if (op.authorizationRole !== null) {
+        op.authorizationRole = props.role;
+      }
+
+      // validate responseBody.typeName -> must be ~.IAuthorized
+      if (op.authorizationType === null) return;
+      else if (op.responseBody === null)
+        errors.push({
+          path: `$input.operations.${i}.responseBody`,
+          expected:
+            "Response body with I{RoleName(PascalCase)}.IAuthorized type is required",
+          value: op.responseBody,
+          description: StringUtil.trim`
+            Response body is required for authentication operations.
+
+            The responseBody must contain description and typeName fields.
+            typeName must be I{Prefix(PascalCase)}{RoleName(PascalCase)}.IAuthorized
+            description must be a detailed description of the response body.
+          `,
+        });
+      else if (!op.responseBody.typeName.endsWith(".IAuthorized"))
+        errors.push({
+          path: `$input.operations.${i}.responseBody.typeName`,
+          expected: `Type name must be I{RoleName(PascalCase)}.IAuthorized`,
+          value: op.responseBody?.typeName,
+          description: StringUtil.trim`
+            Wrong response body type name: ${op.responseBody?.typeName}
+
+            For authentication operations (login, join, refresh), the response body type name must follow the convention "I{RoleName}.IAuthorized".
+
+            This standardized naming convention ensures consistency across all authentication endpoints and clearly identifies authorization response types.
+            The Role name should be in PascalCase format (e.g., IUser.IAuthorized, IAdmin.IAuthorized, ISeller.IAuthorized).
+          `,
+        });
+    });
+
+    // validate authorization types' existence
+    type AuthorizationType = NonNullable<
+      AutoBeOpenApi.IOperation["authorizationType"]
+    >;
+    const authorizationTypes: Set<AuthorizationType> = new Set(
+      result.data.operations
+        .map((o) => o.authorizationType)
+        .filter((v) => v !== null),
+    );
+    for (const type of typia.misc.literals<AuthorizationType>())
+      if (authorizationTypes.has(type) === false)
+        errors.push({
+          path: "$input.operations[].authorizationType",
+          expected: StringUtil.trim`{
+          ...(AutoBeOpenApi.IOperation data),
+          authorizationType: "${type}"
+        }`,
+          value: `No authorizationType "${type}" found in any operation`,
+          description: StringUtil.trim`
+          There must be an operation that has defined AutoBeOpenApi.IOperation.authorizationType := "${type}"
+          for the "${props.role}" role's authorization activity; "${type}".
+
+          However, none of the operations have the AutoBeOpenApi.IOperation.authorizationType := "${type}" 
+          value, so that the "${props.role}" cannot perform the authorization ${type} activity.
+
+          Please make that operation at the next function calling. You have to do it.
+        `,
+        });
+    if (errors.length !== 0) {
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    }
+    return result;
+  };
+
   const application: ILlmApplication<Model> = collection[
-    props.model
-  ] as unknown as ILlmApplication<Model>;
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -90,17 +194,23 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeInterfaceAuthorizationsApplication,
-  "claude"
->();
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceAuthorizationsApplication,
-    "chatgpt"
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "chatgpt">(
+      {
+        validate: {
+          makeOperations: validate,
+        },
+      },
+    ),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "claude">({
+      validate: {
+        makeOperations: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps>;

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -8,6 +8,7 @@ import {
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
@@ -70,6 +71,7 @@ async function step<Model extends ILlmSchema.Model>(
     );
   ctx.dispatch({
     type: "interfaceComplement",
+    id: v7(),
     missed,
     schemas: pointer.value,
     tokenUsage,

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -2,14 +2,17 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeInterfaceEndpointsEvent,
   AutoBeOpenApi,
+  AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { HashSet, IPointer } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceEndpointHistories } from "./histories/transformInterfaceEndpointHistories";
 import { IAutoBeInterfaceEndpointApplication } from "./structures/IAutoBeInterfaceEndpointApplication";
 import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
@@ -22,13 +25,16 @@ export async function orchestrateInterfaceEndpoints<
   authorizations: AutoBeOpenApi.IOperation[],
   content: string = `Make endpoints for the given assets`,
 ): Promise<AutoBeOpenApi.IEndpoint[]> {
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: groups.length,
     completed: 0,
   };
   const endpoints: AutoBeOpenApi.IEndpoint[] = (
-    await Promise.all(
-      groups.map((g) => process(ctx, g, content, progress, authorizations)),
+    await executeCachedBatch(
+      groups.map(
+        (g) => (promptCacheKey) =>
+          process(ctx, g, content, progress, authorizations, promptCacheKey),
+      ),
     )
   ).flat();
   return new HashSet(
@@ -42,8 +48,9 @@ async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   group: AutoBeInterfaceGroup,
   message: string,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
   authorizations: AutoBeOpenApi.IOperation[],
+  promptCacheKey: string,
 ): Promise<AutoBeOpenApi.IEndpoint[]> {
   const start: Date = new Date();
   const pointer: IPointer<AutoBeOpenApi.IEndpoint[] | null> = {
@@ -64,12 +71,14 @@ async function process<Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
+    promptCacheKey,
     message,
   });
   if (pointer.value === null) throw new Error("Failed to generate endpoints."); // unreachable
 
   const event: AutoBeInterfaceEndpointsEvent = {
     type: "interfaceEndpoints",
+    id: v7(),
     endpoints: new HashSet(
       pointer.value,
       OpenApiEndpointComparator.hashCode,
@@ -120,8 +129,3 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
-
-interface IProgress {
-  total: number;
-  completed: number;
-}

package/src/orchestrate/interface/orchestrateInterfaceGroups.ts

@@ -1,12 +1,9 @@
-import { IAgenticaController, MicroAgenticaHistory } from "@agentica/core";
-import {
-  AutoBeAssistantMessageHistory,
-  AutoBeInterfaceGroupsEvent,
-} from "@autobe/interface";
+import { IAgenticaController } from "@agentica/core";
+import { AutoBeInterfaceGroupsEvent } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
-import { v4 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
@@ -18,12 +15,12 @@ export async function orchestrateInterfaceGroups<
 >(
   ctx: AutoBeContext<Model>,
   message: string = "Design API operations for the given assets.",
-): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceGroupsEvent> {
+): Promise<AutoBeInterfaceGroupsEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBeInterfaceGroupApplication.IProps | null> = {
     value: null,
   };
-  const { histories, tokenUsage } = await ctx.conversate({
+  const { tokenUsage } = await ctx.conversate({
     source: "interfaceGroups",
     histories: transformInterfaceGroupHistories(ctx.state()),
     controller: createController({
@@ -32,21 +29,13 @@ export async function orchestrateInterfaceGroups<
         pointer.value = next;
       },
     }),
-    enforceFunctionCall: false,
+    enforceFunctionCall: true,
     message,
   });
-  const last: MicroAgenticaHistory<Model> = histories.at(-1)!;
-  if (last.type === "assistantMessage")
-    return {
-      ...last,
-      created_at: start.toISOString(),
-      completed_at: new Date().toISOString(),
-      id: v4(),
-    } satisfies AutoBeAssistantMessageHistory;
-  else if (pointer.value === null)
-    throw new Error("Failed to generate groups."); // unreachable
+  if (pointer.value === null) throw new Error("Failed to generate groups."); // unreachable
   return {
     type: "interfaceGroups",
+    id: v7(),
     created_at: start.toISOString(),
     groups: pointer.value.groups,
     tokenUsage,

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -2,6 +2,7 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeInterfaceOperationsEvent,
   AutoBeOpenApi,
+  AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeEndpointComparator, StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
@@ -9,11 +10,13 @@ import { HashMap, HashSet, IPointer } from "tstl";
 import typia from "typia";
 import { Escaper } from "typia/lib/utils/Escaper";
 import { NamingConvention } from "typia/lib/utils/NamingConvention";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { emplaceMap } from "../../utils/emplaceMap";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceOperationHistories } from "./histories/transformInterfaceOperationHistories";
 import { orchestrateInterfaceOperationsReview } from "./orchestrateInterfaceOperationsReview";
 import { IAutoBeInterfaceOperationApplication } from "./structures/IAutoBeInterfaceOperationApplication";
@@ -24,46 +27,43 @@ export async function orchestrateInterfaceOperations<
 >(
   ctx: AutoBeContext<Model>,
   endpoints: AutoBeOpenApi.IEndpoint[],
-  capacity: number = 12,
+  capacity: number = 8,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const matrix: AutoBeOpenApi.IEndpoint[][] = divideArray({
     array: endpoints,
     capacity,
   });
-  const operationsProgress: IProgress = {
-    total: endpoints.length,
-    completed: 0,
-  };
-
-  const operationsReviewProgress: IProgress = {
-    total: endpoints.length,
-    completed: 0,
-  };
 
-  const operations: AutoBeOpenApi.IOperation[] = (
-    await Promise.all(
-      matrix.map(async (it) => {
+  return (
+    await executeCachedBatch(
+      matrix.map((it) => async (promptCacheKey) => {
         const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
           ctx,
           it,
           3,
-          operationsProgress,
-          operationsReviewProgress,
+          {
+            total: matrix.length,
+            completed: 0,
+          },
+          {
+            total: matrix.length,
+            completed: 0,
+          },
+          promptCacheKey,
         );
         return row;
       }),
     )
   ).flat();
-
-  return operations;
 }
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   endpoints: AutoBeOpenApi.IEndpoint[],
   retry: number,
-  operationsProgress: IProgress,
-  operationsReviewProgress: IProgress,
+  operationsProgress: AutoBeProgressEventBase,
+  operationsReviewProgress: AutoBeProgressEventBase,
+  promptCacheKey: string,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const remained: HashSet<AutoBeOpenApi.IEndpoint> = new HashSet(
     endpoints,
@@ -77,29 +77,30 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
     );
   for (let i: number = 0; i < retry; ++i) {
     if (remained.empty() === true || unique.size() >= endpoints.length) break;
-    const operations: AutoBeOpenApi.IOperation[] = await process(
-      ctx,
-      Array.from(remained),
-      operationsProgress,
-    );
-    const newbie: AutoBeOpenApi.IOperation[] =
-      await orchestrateInterfaceOperationsReview(
-        ctx,
-        operations,
-        operationsReviewProgress,
-      );
-    for (const item of newbie) {
+    const operations: AutoBeOpenApi.IOperation[] = remained.size()
+      ? await process(ctx, remained, operationsProgress, promptCacheKey)
+      : [];
+
+    for (const item of operations) {
       unique.set(item, item);
       remained.erase(item);
     }
   }
+  const newbie: AutoBeOpenApi.IOperation[] =
+    await orchestrateInterfaceOperationsReview(
+      ctx,
+      unique.toJSON().map((it) => it.second),
+      operationsReviewProgress,
+    );
+  for (const item of newbie) unique.set(item, item);
   return unique.toJSON().map((it) => it.second);
 }
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  progress: IProgress,
+  endpoints: HashSet<AutoBeOpenApi.IEndpoint>,
+  progress: AutoBeProgressEventBase,
+  promptCacheKey: string,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
   const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
@@ -107,7 +108,10 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceOperations",
-    histories: transformInterfaceOperationHistories(ctx.state(), endpoints),
+    histories: transformInterfaceOperationHistories(
+      ctx.state(),
+      endpoints.toJSON(),
+    ),
     controller: createController({
       model: ctx.model,
       roles: ctx.state().analyze?.roles.map((it) => it.name) ?? [],
@@ -124,9 +128,9 @@ async function process<Model extends ILlmSchema.Model>(
                     .filter((it) => it !== "")
                     .join("/"),
                 authorizationRole: null,
+                authorizationType: null,
               },
             ];
-
           return op.authorizationRoles.map((role) => ({
             ...op,
             path:
@@ -135,22 +139,31 @@ async function process<Model extends ILlmSchema.Model>(
                 .filter((it) => it !== "")
                 .join("/"),
             authorizationRole: role,
+            authorizationType: null,
           }));
         });
+        pointer.value.push(...matrix.flat());
         progress.completed += matrix.flat().length;
-        progress.total += matrix
-          .filter((it) => it.length > 1)
-          .map((it) => it.length - 1)
+        progress.total += operations
+          .map((op) =>
+            endpoints.has({ path: op.path, method: op.method })
+              ? op.authorizationRoles.length === 0
+                ? 0
+                : op.authorizationRoles.length - 1
+              : op.authorizationRoles.length,
+          )
           .reduce((a, b) => a + b, 0);
-        pointer.value.push(...matrix.flat());
       },
     }),
     enforceFunctionCall: true,
+    promptCacheKey,
     message: "Make API operations",
   });
   if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
+
   ctx.dispatch({
     type: "interfaceOperations",
+    id: v7(),
     operations: pointer.value,
     tokenUsage,
     ...progress,
@@ -212,13 +225,13 @@ function createController<Model extends ILlmSchema.Model>(props: {
           errors.push({
             path: `$input.operations[${i}].authorizationRoles[${j}]`,
             expected: `null | ${props.roles.map((str) => JSON.stringify(str)).join(" | ")}`,
-            description: [
-              `Role "${role}" is not defined in the roles list.`,
-              "",
-              "Please select one of them below, or do not define (`null`):  ",
-              "",
-              ...props.roles.map((role) => `- ${role}`),
-            ].join("\n"),
+            description: StringUtil.trim`
+              Role "${role}" is not defined in the roles list.
+
+              Please select one of them below, or do not define (\`null\`):  
+
+              ${props.roles.map((role) => `- ${role}`).join("\n")}
+            `,
             value: role,
           });
         });
@@ -241,15 +254,16 @@ function createController<Model extends ILlmSchema.Model>(props: {
           path: `$input.operations[${i}].{"path"|"method"}`,
           expected: "Unique endpoint (path and method)",
           value: key,
-          description: [
-            `Duplicated endpoint detected (method: ${op.method}, path: ${op.path}).`,
-            "",
-            "The duplicated endpoints of others are located in below accessors.",
-            "Check them, and consider which operation endpoint would be proper to modify.",
-            ...indexes.map(
-              (idx) => `- $input.operations.[${idx}].{"path"|"method"}`,
-            ),
-          ].join("\n"),
+          description: StringUtil.trim`
+            Duplicated endpoint detected (method: ${op.method}, path: ${op.path}).
+
+            The duplicated endpoints of others are located in below accessors.
+            Check them, and consider which operation endpoint would be proper to modify.
+            
+            ${indexes
+              .map((idx) => `- $input.operations.[${idx}].{"path"|"method"}`)
+              .join("\n")}
+          `,
         });
         indexes.push(i);
       } else endpoints.emplace(key, [i]);
@@ -270,25 +284,24 @@ function createController<Model extends ILlmSchema.Model>(props: {
           path: `$input.operations[${i}].name`,
           expected: "Unique name in the same accessor scope.",
           value: op.name,
-          description: [
-            `Duplicated operation accessor detected (name: ${op.name}, accessor: ${key}).`,
-            "",
-            "The operation name must be unique within the parent accessor.",
-            "In other worlds, the operation accessor determined by the name",
-            "must be unique in the OpenAPI document.",
-            "",
-            "Here is the list of elements of duplicated operation names.",
-            "Check them, and consider which operation name would be proper to modify.",
-            "",
-            ...indexes
+          description: StringUtil.trim`
+            Duplicated operation accessor detected (name: ${op.name}, accessor: ${key}).
+
+            The operation name must be unique within the parent accessor.
+            In other worlds, the operation accessor determined by the name
+            must be unique in the OpenAPI document.
+
+            Here is the list of elements of duplicated operation names.
+            Check them, and consider which operation name would be proper to modify.
+
+            ${indexes
               .map((idx) => `- ${operations[idx].name} (accessor: ${key})`)
-              .join("\n"),
-          ].join("\n"),
+              .join("\n")}
+          `,
         });
       }
       indexes.push(i);
     });
-
     if (errors.length !== 0)
       return {
         success: false,
@@ -330,11 +343,6 @@ const collection = {
     }),
 };
 
-interface IProgress {
-  completed: number;
-  total: number;
-}
-
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceOperationApplication.IProps>;