@autobe/agent 0.28.1 → 0.29.1

package/src/orchestrate/interface/orchestrateInterfaceSchemaReview.ts

@@ -1,5 +1,9 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeOpenApi, AutoBeProgressEventBase } from "@autobe/interface";
+import {
+  AutoBeEventSource,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
 import { AutoBeInterfaceSchemaReviewEvent } from "@autobe/interface/src/events/AutoBeInterfaceSchemaReviewEvent";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
@@ -12,7 +16,8 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformInterfaceSchemaReviewHistories } from "./histories/transformInterfaceSchemaReviewHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformInterfaceSchemaReviewHistory } from "./histories/transformInterfaceSchemaReviewHistory";
 import { IAutoBeInterfaceSchemaContentReviewApplication } from "./structures/IAutoBeInterfaceSchemaContentReviewApplication";
 import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
 import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
@@ -31,19 +36,21 @@ export async function orchestrateInterfaceSchemaReview<
   config: IConfig,
   props: {
     document: AutoBeOpenApi.IDocument;
+    schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
     instruction: string;
     progress: AutoBeProgressEventBase;
   },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const typeNames: string[] = Object.keys(props.document.components.schemas);
+  const typeNames: string[] = Object.keys(props.schemas);
   const matrix: string[][] = divideArray({
     array: typeNames,
     capacity: AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
   const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (const y of await executeCachedBatch(
+    ctx,
     matrix.map((it) => async (promptCacheKey) => {
-      const operations: AutoBeOpenApi.IOperation[] =
+      const reviewOperations: AutoBeOpenApi.IOperation[] =
         props.document.operations.filter(
           (op) =>
             (op.requestBody && it.includes(op.requestBody.typeName)) ||
@@ -52,11 +59,11 @@ export async function orchestrateInterfaceSchemaReview<
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
         await divideAndConquer(ctx, config, {
           instruction: props.instruction,
-          operations,
-          everySchemas: props.document.components.schemas,
+          document: props.document,
+          reviewOperations,
           reviewSchemas: it.reduce(
             (acc, cur) => {
-              acc[cur] = props.document.components.schemas[cur];
+              acc[cur] = props.schemas[cur];
               return acc;
             },
             {} as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
@@ -78,79 +85,132 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
   config: IConfig,
   props: {
     instruction: string;
-    operations: AutoBeOpenApi.IOperation[];
-    everySchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    document: AutoBeOpenApi.IDocument;
+    reviewOperations: AutoBeOpenApi.IOperation[];
     reviewSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
     progress: AutoBeProgressEventBase;
     promptCacheKey: string;
   },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   try {
-    const pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IProps | null> =
+    return await process(ctx, config, props);
+  } catch {
+    ++props.progress.completed;
+    return {};
+  }
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  config: IConfig,
+  props: {
+    instruction: string;
+    document: AutoBeOpenApi.IDocument;
+    reviewOperations: AutoBeOpenApi.IOperation[];
+    reviewSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
+): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
+  const preliminary: AutoBePreliminaryController<
+    | "analysisFiles"
+    | "prismaSchemas"
+    | "interfaceOperations"
+    | "interfaceSchemas"
+  > = new AutoBePreliminaryController({
+    application:
+      typia.json.application<IAutoBeInterfaceSchemaContentReviewApplication>(),
+    source: SOURCE,
+    kinds: [
+      "analysisFiles",
+      "prismaSchemas",
+      "interfaceOperations",
+      "interfaceSchemas",
+    ],
+    state: ctx.state(),
+    all: {
+      interfaceOperations: props.document.operations,
+      interfaceSchemas: props.document.components.schemas,
+    },
+    local: {
+      interfaceOperations: props.reviewOperations,
+      interfaceSchemas: props.reviewSchemas,
+    },
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IComplete | null> =
       {
         value: null,
       };
-    const { metric, tokenUsage } = await ctx.conversate({
-      source: "interfaceSchemaReview",
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
       controller: createController({
-        model: ctx.model,
+        preliminary,
         pointer,
+        model: ctx.model,
       }),
-      histories: transformInterfaceSchemaReviewHistories({
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformInterfaceSchemaReviewHistory({
         state: ctx.state(),
         systemPrompt: config.systemPrompt,
         instruction: props.instruction,
-        operations: props.operations,
-        everySchemas: props.everySchemas,
+        reviewOperations: props.reviewOperations,
         reviewSchemas: props.reviewSchemas,
+        preliminary,
       }),
-      enforceFunctionCall: true,
-      promptCacheKey: props.promptCacheKey,
-      message: "Review DTO content completeness and consistency.",
     });
-    if (pointer.value === null) {
-      ++props.progress.completed;
-      return {};
+    if (pointer.value !== null) {
+      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: SOURCE,
+        kind: config.kind,
+        id: v7(),
+        schemas: props.reviewSchemas,
+        review: pointer.value.think.review,
+        plan: pointer.value.think.plan,
+        content,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        step: ctx.state().analyze?.step ?? 0,
+        total: props.progress.total,
+        completed: ++props.progress.completed,
+        created_at: new Date().toISOString(),
+      });
+      return out(result)(content);
     }
-
-    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: "interfaceSchemaReview",
-      kind: config.kind,
-      id: v7(),
-      schemas: props.reviewSchemas,
-      review: pointer.value.think.review,
-      plan: pointer.value.think.plan,
-      content,
-      metric,
-      tokenUsage,
-      step: ctx.state().analyze?.step ?? 0,
-      total: props.progress.total,
-      completed: ++props.progress.completed,
-      created_at: new Date().toISOString(),
-    });
-    return content;
-  } catch {
-    ++props.progress.completed;
-    return {};
-  }
+    return out(result)(null);
+  });
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IProps | null>;
+  pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IComplete | null>;
+  preliminary: AutoBePreliminaryController<
+    | "analysisFiles"
+    | "prismaSchemas"
+    | "interfaceOperations"
+    | "interfaceSchemas"
+  >;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
   const validate = (
     next: unknown,
   ): IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps> => {
-    JsonSchemaFactory.fixPage("content", next);
+    if (
+      typia.is<{
+        request: {
+          type: "complete";
+          schemas: object;
+        };
+      }>(next)
+    )
+      JsonSchemaFactory.fixPage("content", next.request);
 
     const result: IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps> =
       typia.validate<IAutoBeInterfaceSchemaContentReviewApplication.IProps>(
@@ -159,13 +219,17 @@ function createController<Model extends ILlmSchema.Model>(props: {
     if (result.success === false) {
       fulfillJsonSchemaErrorMessages(result.errors);
       return result;
-    }
+    } else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
 
     const errors: IValidation.IError[] = [];
     JsonSchemaValidator.validateSchemas({
       errors,
-      schemas: result.data.content,
-      path: "$input.content",
+      schemas: result.data.request.content,
+      path: "$input.request.content",
     });
     if (errors.length !== 0)
       return {
@@ -187,11 +251,12 @@ function createController<Model extends ILlmSchema.Model>(props: {
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "ContentReviewer",
+    name: SOURCE,
     application,
     execute: {
-      review: (input) => {
-        props.pointer.value = input;
+      process: (input) => {
+        if (input.request.type === "complete")
+          props.pointer.value = input.request;
       },
     } satisfies IAutoBeInterfaceSchemaContentReviewApplication,
   };
@@ -204,7 +269,7 @@ const collection = {
       "chatgpt"
     >({
       validate: {
-        review: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
@@ -213,7 +278,7 @@ const collection = {
       "claude"
     >({
       validate: {
-        review: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
@@ -222,7 +287,7 @@ const collection = {
       "gemini"
     >({
       validate: {
-        review: validate,
+        process: validate,
       },
     }),
 };
@@ -230,3 +295,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps>;
+
+const SOURCE = "interfaceSchemaReview" satisfies AutoBeEventSource;

package/src/orchestrate/interface/structures/IAutoBeInterfaceAuthorizationsApplication.ts

@@ -1,19 +1,77 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 import { tags } from "typia";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceAuthorizationsApplication {
   /**
-   * Creates an authorization Operations for the given roles
+   * Process authorization operations generation task or preliminary data
+   * requests.
+   *
+   * Generates authorization operations for the given roles and ensures the
+   * interface reflects correct permissions and access levels.
    *
-   * This method generates an OpenAPI interface that defines the authorization
-   * requirements for the given roles. It ensures that the interface reflects
-   * the correct permissions and access levels for each role.
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  makeOperations(props: IAutoBeInterfaceAuthorizationsApplication.IProps): void;
+  process(props: IAutoBeInterfaceAuthorizationsApplication.IProps): void;
 }
 
 export namespace IAutoBeInterfaceAuthorizationsApplication {
   export interface IProps {
+    /**
+     * Think before you act.
+     *
+     * Before requesting preliminary data or completing your task, reflect on your
+     * current state and explain your reasoning:
+     *
+     * For preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):
+     * - What critical information is missing that you don't already have?
+     * - Why do you need it specifically right now?
+     * - Be brief - state the gap, don't list everything you have.
+     *
+     * For completion (complete):
+     * - What key assets did you acquire?
+     * - What did you accomplish?
+     * - Why is it sufficient to complete?
+     * - Summarize - don't enumerate every single item.
+     *
+     * This reflection helps you avoid duplicate requests and premature completion.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas) or final authorization operations
+     * generation (complete). When preliminary returns empty array, that type is
+     * removed from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas;
+  }
+
+  /**
+   * Request to generate authorization operations.
+   *
+   * Executes authorization operations generation to define the authorization
+   * requirements for the given roles. Ensures operations reflect correct
+   * permissions and access levels for each role.
+   */
+  export interface IComplete {
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval or actual
+     * task execution. Value "complete" indicates this is the final task
+     * execution request.
+     */
+    type: "complete";
+
     /**
      * Array of API operations to generate authorization operation for.
      *

package/src/orchestrate/interface/structures/IAutoBeInterfaceComplementApplication.ts

@@ -1,25 +1,80 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetInterfaceOperations";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceComplementApplication {
   /**
-   * Complements missing schema types
+   * Process schema complement task or preliminary data requests.
    *
-   * This method fills in schema definitions that are referenced via $ref but
-   * not yet defined in the `components.schemas` section. For example, if an API
-   * operation references `{ "$ref": "#/components/schemas/UserProfile" }` but
-   * `UserProfile` type is not defined in `components.schemas`, this method will
-   * add the missing schema definition.
+   * Adds missing schema definitions to ensure OpenAPI document is complete and
+   * all referenced schemas are properly defined.
    *
-   * This function is designed to be called via AI function calling mechanism to
-   * ensure the OpenAPI document is complete and all referenced schemas are
-   * properly defined.
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  complementComponents(
-    props: IAutoBeInterfaceComplementApplication.IProps,
-  ): void;
+  process(props: IAutoBeInterfaceComplementApplication.IProps): void;
 }
+
 export namespace IAutoBeInterfaceComplementApplication {
   export interface IProps {
+    /**
+     * Think before you act.
+     *
+     * Before requesting preliminary data or completing your task, reflect on your
+     * current state and explain your reasoning:
+     *
+     * For preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):
+     * - What critical information is missing that you don't already have?
+     * - Why do you need it specifically right now?
+     * - Be brief - state the gap, don't list everything you have.
+     *
+     * For completion (complete):
+     * - What key assets did you acquire?
+     * - What did you accomplish?
+     * - Why is it sufficient to complete?
+     * - Summarize - don't enumerate every single item.
+     *
+     * This reflection helps you avoid duplicate requests and premature completion.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas, getInterfaceOperations,
+     * getInterfaceSchemas) or final schema complementation (complete). When
+     * preliminary returns empty array, that type is removed from the union,
+     * physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas
+      | IAutoBePreliminaryGetInterfaceOperations
+      | IAutoBePreliminaryGetInterfaceSchemas;
+  }
+
+  /**
+   * Request to add missing schema definitions.
+   *
+   * Executes schema complementation to fill in referenced but undefined schema
+   * types in the OpenAPI document's components.schemas section. Ensures all
+   * $ref references resolve to valid schema definitions.
+   */
+  export interface IComplete {
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval or actual
+     * task execution. Value "complete" indicates this is the final task
+     * execution request.
+     */
+    type: "complete";
+
     /**
      * A collection of missing schema definitions that need to be added to the
      * OpenAPI document's `components.schemas` section.

package/src/orchestrate/interface/structures/IAutoBeInterfaceEndpointApplication.ts

@@ -1,24 +1,77 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 import { tags } from "typia";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceEndpointApplication {
   /**
-   * Create Restful API endpoints.
-   *
-   * Create Restful API endpoints referencing the given documents; requirement
-   * analysis documents, and Prisma schema files with ERD descriptions. The API
-   * endpoints must cover every requirements and every entities in the ERD.
+   * Process endpoint generation task or preliminary data requests.
    *
-   * Also, each combination of {@link AutoBeOpenApi.IEndpoint.path} and
-   * {@link AutoBeOpenApi.IEndpoint.method} must be unique to avoid duplicates.
-   * Please don't make any duplicates.
+   * Creates Restful API endpoints referencing requirement analysis documents and
+   * Prisma schema files with ERD descriptions. Ensures endpoints cover all
+   * requirements and entities.
    *
-   * @param props Properties containing the endpoints
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  makeEndpoints(props: IAutoBeInterfaceEndpointApplication.IProps): void;
+  process(props: IAutoBeInterfaceEndpointApplication.IProps): void;
 }
+
 export namespace IAutoBeInterfaceEndpointApplication {
   export interface IProps {
+    /**
+     * Think before you act.
+     *
+     * Before requesting preliminary data or completing your task, reflect on your
+     * current state and explain your reasoning:
+     *
+     * For preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):
+     * - What critical information is missing that you don't already have?
+     * - Why do you need it specifically right now?
+     * - Be brief - state the gap, don't list everything you have.
+     *
+     * For completion (complete):
+     * - What key assets did you acquire?
+     * - What did you accomplish?
+     * - Why is it sufficient to complete?
+     * - Summarize - don't enumerate every single item.
+     *
+     * This reflection helps you avoid duplicate requests and premature completion.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas) or final endpoint generation
+     * (complete). When preliminary returns empty array, that type is removed
+     * from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas;
+  }
+
+  /**
+   * Request to create Restful API endpoints.
+   *
+   * Executes endpoint generation to create comprehensive API endpoints covering
+   * all requirements and entities. Each combination of path and method must be
+   * unique to avoid duplicates.
+   */
+  export interface IComplete {
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval or actual
+     * task execution. Value "complete" indicates this is the final task
+     * execution request.
+     */
+    type: "complete";
+
     /** The endpoints to generate. */
     endpoints: AutoBeOpenApi.IEndpoint[] & tags.MinItems<1>;
   }

package/src/orchestrate/interface/structures/IAutoBeInterfaceEndpointReviewApplication.ts

@@ -0,0 +1,106 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
+export interface IAutoBeInterfaceEndpointReviewApplication {
+  /**
+   * Process endpoint review task or preliminary data requests.
+   *
+   * Consolidates all endpoints generated independently and performs holistic
+   * review to ensure consistency, remove duplicates, eliminate
+   * over-engineering, and verify REST API design principles.
+   *
+   * @param props Request containing either preliminary data request or complete
+   *   task
+   */
+  process(props: IAutoBeInterfaceEndpointReviewApplication.IProps): void;
+}
+
+export namespace IAutoBeInterfaceEndpointReviewApplication {
+  export interface IProps {
+    /**
+     * Think before you act.
+     *
+     * Before requesting preliminary data or completing your task, reflect on your
+     * current state and explain your reasoning:
+     *
+     * For preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):
+     * - What critical information is missing that you don't already have?
+     * - Why do you need it specifically right now?
+     * - Be brief - state the gap, don't list everything you have.
+     *
+     * For completion (complete):
+     * - What key assets did you acquire?
+     * - What did you accomplish?
+     * - Why is it sufficient to complete?
+     * - Summarize - don't enumerate every single item.
+     *
+     * This reflection helps you avoid duplicate requests and premature completion.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas) or final endpoint review (complete).
+     * When preliminary returns empty array, that type is removed from the
+     * union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas;
+  }
+
+  /**
+   * Request to review and refine API endpoints.
+   *
+   * Executes comprehensive endpoint review to consolidate independently
+   * generated endpoints, ensure consistency, eliminate redundancy, and create a
+   * clean, maintainable API structure following REST best practices.
+   */
+  export interface IComplete {
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval or actual
+     * task execution. Value "complete" indicates this is the final task
+     * execution request.
+     */
+    type: "complete";
+
+    /**
+     * Comprehensive review analysis of all collected endpoints.
+     *
+     * Contains detailed findings from the holistic review including:
+     *
+     * - Identified inconsistencies in naming conventions
+     * - Duplicate endpoints that serve the same purpose
+     * - Over-engineered solutions that add unnecessary complexity
+     * - Violations of REST API design principles
+     * - Recommendations for improvement and standardization
+     *
+     * The review provides actionable feedback for creating a clean, consistent,
+     * and maintainable API structure.
+     */
+    review: string;
+
+    /**
+     * Refined collection of API endpoints after review and cleanup.
+     *
+     * The final optimized set of endpoints after:
+     *
+     * - Removing duplicates and redundant endpoints
+     * - Standardizing naming conventions across all paths
+     * - Simplifying over-engineered solutions
+     * - Ensuring consistent REST patterns
+     * - Aligning HTTP methods with their semantic meanings
+     *
+     * This collection represents the production-ready API structure that
+     * balances functionality with simplicity and maintainability.
+     */
+    endpoints: AutoBeOpenApi.IEndpoint[];
+  }
+}