@autobe/agent 0.21.0 → 0.22.1

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -34,21 +34,22 @@ export async function orchestrateInterfaceOperations<
     capacity,
   });
 
+  const progress: AutoBeProgressEventBase = {
+    total: matrix.flat().length,
+    completed: 0,
+  };
+  const reviewProgress: AutoBeProgressEventBase = {
+    total: matrix.length,
+    completed: 0,
+  };
   return (
     await executeCachedBatch(
       matrix.map((it) => async (promptCacheKey) => {
         const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
           ctx,
           it,
-          3,
-          {
-            total: matrix.length,
-            completed: 0,
-          },
-          {
-            total: matrix.length,
-            completed: 0,
-          },
+          progress,
+          reviewProgress,
           promptCacheKey,
         );
         return row;
@@ -60,7 +61,6 @@ export async function orchestrateInterfaceOperations<
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   endpoints: AutoBeOpenApi.IEndpoint[],
-  retry: number,
   operationsProgress: AutoBeProgressEventBase,
   operationsReviewProgress: AutoBeProgressEventBase,
   promptCacheKey: string,
@@ -75,7 +75,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
       OpenApiEndpointComparator.hashCode,
       OpenApiEndpointComparator.equals,
     );
-  for (let i: number = 0; i < retry; ++i) {
+  for (let i: number = 0; i < ctx.retry; ++i) {
     if (remained.empty() === true || unique.size() >= endpoints.length) break;
     const operations: AutoBeOpenApi.IOperation[] = remained.size()
       ? await process(ctx, remained, operationsProgress, promptCacheKey)

package/src/orchestrate/interface/orchestrateInterfaceOperationsReview.ts

@@ -5,7 +5,7 @@ import {
   AutoBePrisma,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
@@ -42,7 +42,7 @@ export async function orchestrateInterfaceOperationsReview<
     });
     if (pointer.value === null) {
       console.error("Failed to review operations.");
-      progress.completed += operations.length;
+      ++progress.completed;
       return [];
     }
 
@@ -57,8 +57,8 @@ export async function orchestrateInterfaceOperationsReview<
       type: "interfaceOperationsReview",
       id: v7(),
       operations: content,
-      review: pointer.value.review,
-      plan: pointer.value.plan,
+      review: pointer.value.think.review,
+      plan: pointer.value.think.plan,
       content,
       tokenUsage,
       created_at: new Date().toISOString(),
@@ -79,99 +79,9 @@ function createReviewController<Model extends ILlmSchema.Model>(props: {
   prismaSchemas: AutoBePrisma.IFile[];
   build: (reviews: IAutoBeInterfaceOperationsReviewApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
-  const validate = (
-    next: unknown,
-  ): IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> => {
-    const result: IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> =
-      typia.validate<IAutoBeInterfaceOperationsReviewApplication.IProps>(next);
-    if (result.success === false) return result;
-    const errors: IValidation.IError[] = [];
-
-    const models: AutoBePrisma.IModel[] = props.prismaSchemas.flatMap(
-      (schema) => schema.models,
-    );
-
-    result.data.content.forEach((op, index) => {
-      // Check if summary or description mentions soft delete
-      const mentionsSoftDelete =
-        (op.summary && /soft[\s-]?delet/i.test(op.summary)) ||
-        (op.description && /soft[\s-]?delet/i.test(op.description));
-
-      if (op.method === "delete") {
-        const model = models.find((model) => model.name === op.model_name);
-
-        if (mentionsSoftDelete) {
-          // If soft delete is mentioned but no soft_delete_column is specified
-          if (!op.soft_delete_column) {
-            // Check if any soft-delete capable column exists in the model
-            const hasSoftDeleteCapableColumn = model?.plainFields.some(
-              (field) =>
-                /delete|deleted|deleted_at|deletedAt|is_deleted|isDeleted/i.test(
-                  field.name,
-                ),
-            );
-
-            if (hasSoftDeleteCapableColumn) {
-              errors.push({
-                expected: `Soft delete column to be specified or summary/description to not mention soft delete`,
-                value: "null",
-                description: `Mismatch: Operation mentions soft delete but soft_delete_column is not specified, while model has soft-delete capable columns`,
-                path: `$input.content[${index}].soft_delete_column`,
-              });
-            } else {
-              errors.push({
-                expected: `Summary/description to not mention soft delete when model lacks soft-delete capability`,
-                value: `${op.summary || ""} ${op.description || ""}`,
-                description: `Mismatch: Operation mentions soft delete but model '${op.model_name}' has no soft-delete capable columns`,
-                path: `$input.content[${index}].summary || $input.content[${index}].description`,
-              });
-            }
-          } else {
-            // If soft_delete_column is specified, check if it exists in the model
-            const column = model?.plainFields.find(
-              (el) => el.name === op.soft_delete_column,
-            );
-
-            if (!column) {
-              errors.push({
-                expected: `Field '${op.soft_delete_column}' to exist in model or operation to not mention soft delete`,
-                value: "undefined",
-                description: `Mismatch: Either the field '${op.soft_delete_column}' should exist in model '${op.model_name}', or the operation should not mention soft delete`,
-                path: `$input.content[${index}].soft_delete_column || $input.content[${index}].summary || $input.content[${index}].description`,
-              });
-            }
-          }
-        }
-
-        // Also check if soft_delete_column is specified without mentioning soft delete
-        if (op.soft_delete_column && !mentionsSoftDelete) {
-          errors.push({
-            expected: `Consistency between soft_delete_column and operation description`,
-            value: `soft_delete_column: ${op.soft_delete_column}`,
-            description: `Mismatch: soft_delete_column is specified but soft delete is not mentioned in summary/description`,
-            path: `$input.content[${index}]`,
-          });
-        }
-      }
-    });
-
-    // not implemented
-    if (errors.length !== 0) {
-      console.log(JSON.stringify(errors, null, 2));
-      return {
-        success: false,
-        errors,
-        data: next,
-      };
-    }
-    return result;
-  };
-
   const application: ILlmApplication<Model> = collection[
     props.model === "chatgpt" ? "chatgpt" : "claude"
-  ](
-    validate,
-  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -186,26 +96,12 @@ function createReviewController<Model extends ILlmSchema.Model>(props: {
 }
 
 const collection = {
-  chatgpt: (validate: Validator) =>
-    typia.llm.application<
-      IAutoBeInterfaceOperationsReviewApplication,
-      "chatgpt"
-    >({
-      validate: {
-        reviewOperations: validate,
-      },
-    }),
-  claude: (validate: Validator) =>
-    typia.llm.application<
-      IAutoBeInterfaceOperationsReviewApplication,
-      "claude"
-    >({
-      validate: {
-        reviewOperations: validate,
-      },
-    }),
+  chatgpt: typia.llm.application<
+    IAutoBeInterfaceOperationsReviewApplication,
+    "chatgpt"
+  >(),
+  claude: typia.llm.application<
+    IAutoBeInterfaceOperationsReviewApplication,
+    "claude"
+  >(),
 };
-
-type Validator = (
-  input: unknown,
-) => IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps>;

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -8,7 +8,7 @@ import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
-import typia, { tags } from "typia";
+import typia from "typia";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -16,22 +16,32 @@ import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceSchemaHistories } from "./histories/transformInterfaceSchemaHistories";
-import { orchestrateInterfaceSchemasReview } from "./orchestrateInterfaceSchemasReview";
 import { IAutoBeInterfaceSchemaApplication } from "./structures/IAutoBeInterfaceSchemaApplication";
-import { validateAuthorizationSchema } from "./utils/validateAuthorizationSchema";
+import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
+import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
+import { JsonSchemaValidator } from "./utils/JsonSchemaValidator";
+import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
 
 export async function orchestrateInterfaceSchemas<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
   operations: AutoBeOpenApi.IOperation[],
-  capacity: number = 8,
+  capacity: number = 5,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
+  // fix operation type names
+  JsonSchemaNamingConvention.operations(operations);
+
+  // gather type names
   const typeNames: Set<string> = new Set();
   for (const op of operations) {
     if (op.requestBody !== null) typeNames.add(op.requestBody.typeName);
     if (op.responseBody !== null) typeNames.add(op.responseBody.typeName);
   }
+  const presets: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+    JsonSchemaFactory.presets(typeNames);
+
+  // divide and conquer
   const matrix: string[][] = divideArray({
     array: Array.from(typeNames),
     capacity,
@@ -40,43 +50,22 @@ export async function orchestrateInterfaceSchemas<
     total: typeNames.size,
     completed: 0,
   };
-  const reviewProgress: AutoBeProgressEventBase = {
-    total: matrix.length,
-    completed: 0,
+  const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {
+    ...presets,
   };
-  const roles: string[] =
-    ctx.state().analyze?.roles.map((role) => role.name) ?? [];
-
-  const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-    roles.length > 0
-      ? {
-          IAuthorizationToken: authTokenSchema,
-        }
-      : {};
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(
-          ctx,
-          operations,
-          it,
-          3,
-          progress,
-          promptCacheKey,
-        );
-      const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await orchestrateInterfaceSchemasReview(
-          ctx,
-          operations,
-          row,
-          reviewProgress,
-        );
-      return { ...row, ...newbie };
+        await divideAndConquer(ctx, operations, it, progress, promptCacheKey);
+      return row;
     }),
   )) {
+    JsonSchemaNamingConvention.schemas(operations, x, y);
     Object.assign(x, y);
   }
-  if (x.IAuthorizationToken) x.IAuthorizationToken = authTokenSchema;
+  Object.assign(x, presets);
+  JsonSchemaNamingConvention.schemas(operations, x);
+  JsonSchemaFactory.authorize(x);
   return x;
 }
 
@@ -84,13 +73,12 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operations: AutoBeOpenApi.IOperation[],
   typeNames: string[],
-  retry: number,
   progress: AutoBeProgressEventBase,
   promptCacheKey: string,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const remained: Set<string> = new Set(typeNames);
   const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
-  for (let i: number = 0; i < retry; ++i) {
+  for (let i: number = 0; i < ctx.retry; ++i) {
     if (remained.size === 0) break;
     const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
       await process(
@@ -162,12 +150,11 @@ async function process<Model extends ILlmSchema.Model>(
   });
   if (pointer.value === null) throw new Error("Failed to create components.");
 
-  const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-    (
-      OpenApiV3_1Emender.convertComponents({
-        schemas: pointer.value,
-      }) as AutoBeOpenApi.IComponents
-    ).schemas ?? {};
+  const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = ((
+    OpenApiV3_1Emender.convertComponents({
+      schemas: pointer.value,
+    }) as AutoBeOpenApi.IComponents
+  ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
   ctx.dispatch({
     type: "interfaceSchemas",
     id: v7(),
@@ -198,13 +185,18 @@ function createController<Model extends ILlmSchema.Model>(props: {
   const validate = (
     next: unknown,
   ): IValidation<IAutoBeInterfaceSchemaApplication.IProps> => {
+    JsonSchemaFactory.fix("schemas", next);
+
     const result: IValidation<IAutoBeInterfaceSchemaApplication.IProps> =
       typia.validate<IAutoBeInterfaceSchemaApplication.IProps>(next);
-    if (result.success === false) return result;
+    if (result.success === false) {
+      fulfillJsonSchemaErrorMessages(result.errors);
+      return result;
+    }
 
     // Check all IAuthorized types
     const errors: IValidation.IError[] = [];
-    validateAuthorizationSchema({
+    JsonSchemaValidator.validate({
       errors,
       schemas: result.data.schemas,
       path: "$input.schemas",
@@ -253,53 +245,3 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceSchemaApplication.IProps>;
-
-/**
- * Authorization token response structure.
- *
- * This interface defines the structure of the authorization token response
- * returned after successful user authentication. It contains both access and
- * refresh tokens along with their expiration information.
- *
- * This token structure is automatically included in API schemas when the system
- * detects authorization roles in the requirements analysis phase. It provides a
- * standard format for JWT-based authentication across the generated backend
- * applications.
- */
-interface IAuthorizationToken {
-  /**
-   * JWT access token for authenticated requests.
-   *
-   * This token should be included in the Authorization header for subsequent
-   * authenticated API requests as `Bearer {token}`.
-   */
-  access: string;
-
-  /**
-   * Refresh token for obtaining new access tokens.
-   *
-   * This token can be used to request new access tokens when the current access
-   * token expires, extending the user's session.
-   */
-  refresh: string;
-
-  /**
-   * Access token expiration timestamp.
-   *
-   * ISO 8601 date-time string indicating when the access token will expire and
-   * can no longer be used for authentication.
-   */
-  expired_at: string & tags.Format<"date-time">;
-
-  /**
-   * Refresh token expiration timestamp.
-   *
-   * ISO 8601 date-time string indicating the latest time until which the
-   * refresh token can be used to obtain new access tokens.
-   */
-  refreshable_until: string & tags.Format<"date-time">;
-}
-
-const authTokenSchema: AutoBeOpenApi.IJsonSchemaDescriptive =
-  typia.json.schema<IAuthorizationToken>().components.schemas!
-    .IAuthorizationToken as AutoBeOpenApi.IJsonSchemaDescriptive;

package/src/orchestrate/interface/orchestrateInterfaceSchemasReview.ts

@@ -12,20 +12,67 @@ import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { divideArray } from "../../utils/divideArray";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceSchemasReviewHistories } from "./histories/transformInterfaceSchemasReviewHistories";
 import { IAutoBeInterfaceSchemasReviewApplication } from "./structures/IAutobeInterfaceSchemasReviewApplication";
-import { validateAuthorizationSchema } from "./utils/validateAuthorizationSchema";
+import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
+import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
+import { JsonSchemaValidator } from "./utils/JsonSchemaValidator";
+import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
 
 export async function orchestrateInterfaceSchemasReview<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
   operations: AutoBeOpenApi.IOperation[],
-  schemas: Record<
-    string,
-    AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
-  >,
+  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
+  const a = Object.entries(schemas).map(([key, schema]) => {
+    return { [key]: schema };
+  });
+
+  const matrix: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[][] =
+    divideArray({
+      array: a,
+      capacity: 8,
+    });
+  const progress: IProgress = {
+    total: matrix.length,
+    completed: 0,
+  };
+
+  const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
+  for (const y of await executeCachedBatch(
+    matrix.map((it) => async (promptCacheKey) => {
+      const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+        await divideAndConquer(ctx, operations, it, progress, promptCacheKey);
+      return row;
+    }),
+  )) {
+    JsonSchemaNamingConvention.schemas(operations, x, y);
+    Object.assign(x, y);
+  }
+  return x;
+}
+
+async function divideAndConquer<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[],
+  progress: AutoBeProgressEventBase,
+  promptCacheKey: string,
+): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
+  const schema = schemas.reduce((acc, cur) => Object.assign(acc, cur), {});
+  return step(ctx, operations, schema, progress, promptCacheKey);
+}
+
+export async function step<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
   progress: AutoBeProgressEventBase,
+  promptCacheKey: string,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   try {
     const pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null> =
@@ -46,6 +93,7 @@ export async function orchestrateInterfaceSchemasReview<
         schemas,
       ),
       enforceFunctionCall: true,
+      promptCacheKey,
       message: "Review type schemas.",
     });
     if (pointer.value === null) {
@@ -54,18 +102,18 @@ export async function orchestrateInterfaceSchemasReview<
       return {};
     }
 
-    const content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-      (
-        OpenApiV3_1Emender.convertComponents({
-          schemas: pointer.value.content,
-        }) as AutoBeOpenApi.IComponents
-      ).schemas ?? {};
+    const content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = ((
+      OpenApiV3_1Emender.convertComponents({
+        schemas: pointer.value.content,
+      }) as AutoBeOpenApi.IComponents
+    ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+
     ctx.dispatch({
       type: "interfaceSchemasReview",
       id: v7(),
       schemas: schemas,
-      review: pointer.value.review,
-      plan: pointer.value.plan,
+      review: pointer.value.think.review,
+      plan: pointer.value.think.plan,
       content,
       tokenUsage,
       step: ctx.state().analyze?.step ?? 0,
@@ -85,110 +133,34 @@ function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null>;
   operations: AutoBeOpenApi.IOperation[];
-  schemas: Record<
-    string,
-    AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
-  >;
+  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
   const validate = (
     next: unknown,
   ): IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> => {
+    JsonSchemaFactory.fix("content", next);
+
     const result: IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> =
       typia.validate<IAutoBeInterfaceSchemasReviewApplication.IProps>(next);
-    if (result.success === false) return result;
+    if (result.success === false) {
+      fulfillJsonSchemaErrorMessages(result.errors);
+      return result;
+    }
 
     const errors: IValidation.IError[] = [];
-    validateAuthorizationSchema({
+    JsonSchemaValidator.validate({
       errors,
       schemas: result.data.content,
       path: "$input.content",
     });
-
-    Object.entries(result.data.content).forEach(
-      ([tagName, jsonDescriptive]) => {
-        const index: AutoBeOpenApi.IOperation | undefined =
-          props.operations.find(
-            (op) =>
-              op.responseBody?.typeName === tagName &&
-              op.method === "patch" &&
-              op.name === "index",
-          );
-
-        // The index API should return the `IPage<T>` type.
-        if (index) {
-          // First check if the schema has the correct object structure
-          if (
-            !("type" in jsonDescriptive) ||
-            jsonDescriptive.type !== "object"
-          ) {
-            errors.push({
-              path: `$input.content.${tagName}`,
-              expected: `{ type: "object", properties: { ... } }`,
-              value: jsonDescriptive,
-              description: `IPage schema must have type: "object". Found: ${JSON.stringify(jsonDescriptive)}`,
-            });
-          } else if (!("properties" in jsonDescriptive)) {
-            errors.push({
-              path: `$input.content.${tagName}`,
-              expected: `Schema with "properties" field`,
-              value: jsonDescriptive,
-              description: `IPage schema must have a "properties" field containing "pagination" and "data" properties.`,
-            });
-          } else if (
-            typia.is<AutoBeOpenApi.IJsonSchema.IObject>(jsonDescriptive)
-          ) {
-            jsonDescriptive.properties ??= {};
-
-            // Check pagination property
-            const pagination = jsonDescriptive.properties["pagination"];
-            if (!pagination || !("$ref" in pagination)) {
-              errors.push({
-                path: `$input.content.${tagName}.properties.pagination`,
-                expected: `{ $ref: "#/components/schemas/IPage.IPagination" }`,
-                value: pagination,
-                description: `IPage must have a "pagination" property with $ref to IPage.IPagination.`,
-              });
-            }
-
-            // Check data property
-            const data = jsonDescriptive.properties["data"];
-            if (!typia.is<AutoBeOpenApi.IJsonSchema.IArray>(data)) {
-              errors.push({
-                path: `$input.content.${tagName}.properties.data`,
-                expected: `AutoBeOpenApi.IJsonSchema.IArray`,
-                value: data,
-                description: `The 'data' property must be an array for the index operation.`,
-              });
-            } else {
-              // Check if array items have proper type reference (not 'any')
-              const arraySchema: AutoBeOpenApi.IJsonSchema.IArray = data;
-              if (
-                !arraySchema.items ||
-                !("$ref" in arraySchema.items) ||
-                arraySchema.items.$ref === "#/components/schemas/any"
-              ) {
-                errors.push({
-                  path: `$input.content.${tagName}.properties.data.items`,
-                  expected: `Reference to a specific type (e.g., $ref to ISummary type)`,
-                  value: arraySchema.items,
-                  description: `The 'data' array must have a specific item type, not 'any[]'. Use a proper type reference like '{Entity}.ISummary' for paginated results.`,
-                });
-              }
-            }
-          }
-        }
-      },
-    );
-
     if (errors.length !== 0)
       return {
         success: false,
         errors,
         data: next,
       };
-
     return result;
   };
 
@@ -227,3 +199,8 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps>;
+
+export interface IProgress {
+  total: number;
+  completed: number;
+}