@autobe/agent 0.25.7 → 0.26.0

package/src/orchestrate/interface/{orchestrateInterfaceSchemasReview.ts → orchestrateInterfaceSchemaReview.ts}

@@ -1,9 +1,5 @@
 import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeInterfaceSchemasReviewEvent,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-} from "@autobe/interface";
+import { AutoBeOpenApi, AutoBeProgressEventBase } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
@@ -15,31 +11,38 @@ 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 { transformInterfaceSchemaReviewHistories } from "./histories/transformInterfaceSchemaReviewHistories";
+import { IAutoBeInterfaceSchemaContentReviewApplication } from "./structures/IAutoBeInterfaceSchemaContentReviewApplication";
 import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
 import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
 import { JsonSchemaValidator } from "./utils/JsonSchemaValidator";
 import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
 
-export async function orchestrateInterfaceSchemasReview<
+interface IConfig {
+  type:
+    | "interfaceSchemaContentReview"
+    | "interfaceSchemaSecurityReview"
+    | "interfaceSchemaRelationReview";
+  systemPrompt: string;
+}
+
+export async function orchestrateInterfaceSchemaReview<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+  config: IConfig,
+  props: {
+    document: AutoBeOpenApi.IDocument;
+    instruction: string;
+  },
   capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const a = Object.entries(schemas).map(([key, schema]) => {
-    return { [key]: schema };
+  const typeNames: string[] = Object.keys(props.document.components.schemas);
+  const matrix: string[][] = divideArray({
+    array: typeNames,
+    capacity,
   });
-
-  const matrix: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[][] =
-    divideArray({
-      array: a,
-      capacity,
-    });
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: matrix.length,
     completed: 0,
   };
@@ -47,12 +50,31 @@ export async function orchestrateInterfaceSchemasReview<
   const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
+      const operations: AutoBeOpenApi.IOperation[] =
+        props.document.operations.filter(
+          (op) =>
+            (op.requestBody && it.includes(op.requestBody.typeName)) ||
+            (op.responseBody && it.includes(op.responseBody.typeName)),
+        );
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(ctx, operations, it, progress, promptCacheKey);
+        await divideAndConquer(ctx, config, {
+          instruction: props.instruction,
+          operations,
+          everySchemas: props.document.components.schemas,
+          reviewSchemas: it.reduce(
+            (acc, cur) => {
+              acc[cur] = props.document.components.schemas[cur];
+              return acc;
+            },
+            {} as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+          ),
+          progress,
+          promptCacheKey,
+        });
       return row;
     }),
   )) {
-    JsonSchemaNamingConvention.schemas(operations, x, y);
+    JsonSchemaNamingConvention.schemas(props.document.operations, x, y);
     Object.assign(x, y);
   }
   return x;
@@ -60,46 +82,41 @@ export async function orchestrateInterfaceSchemasReview<
 
 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,
+  config: IConfig,
+  props: {
+    instruction: string;
+    operations: AutoBeOpenApi.IOperation[];
+    everySchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    reviewSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   try {
-    const pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null> =
+    const pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IProps | null> =
       {
         value: null,
       };
     const { tokenUsage } = await ctx.conversate({
-      source: "interfaceSchemasReview",
+      source: "interfaceSchemaContentReview",
       controller: createController({
         model: ctx.model,
         pointer,
-        operations,
-        schemas,
       }),
-      histories: transformInterfaceSchemasReviewHistories(
-        ctx.state(),
-        operations,
-        schemas,
-      ),
+      histories: transformInterfaceSchemaReviewHistories({
+        state: ctx.state(),
+        systemPrompt: config.systemPrompt,
+        instruction: props.instruction,
+        operations: props.operations,
+        everySchemas: props.everySchemas,
+        reviewSchemas: props.reviewSchemas,
+      }),
       enforceFunctionCall: true,
-      promptCacheKey,
-      message: "Review type schemas.",
+      promptCacheKey: props.promptCacheKey,
+      message: "Review DTO content completeness and consistency.",
     });
     if (pointer.value === null) {
-      ++progress.completed;
+      ++props.progress.completed;
       return {};
     }
 
@@ -110,40 +127,40 @@ export async function step<Model extends ILlmSchema.Model>(
     ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
 
     ctx.dispatch({
-      type: "interfaceSchemasReview",
+      type: config.type,
       id: v7(),
-      schemas: schemas,
+      schemas: props.reviewSchemas,
       review: pointer.value.think.review,
       plan: pointer.value.think.plan,
       content,
       tokenUsage,
       step: ctx.state().analyze?.step ?? 0,
-      total: progress.total,
-      completed: ++progress.completed,
+      total: props.progress.total,
+      completed: ++props.progress.completed,
       created_at: new Date().toISOString(),
-    } satisfies AutoBeInterfaceSchemasReviewEvent);
+    });
     return content;
   } catch {
-    ++progress.completed;
+    ++props.progress.completed;
     return {};
   }
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null>;
-  operations: AutoBeOpenApi.IOperation[];
-  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IProps | null>;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
   const validate = (
     next: unknown,
-  ): IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> => {
+  ): IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps> => {
     JsonSchemaFactory.fixPage("content", next);
 
-    const result: IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> =
-      typia.validate<IAutoBeInterfaceSchemasReviewApplication.IProps>(next);
+    const result: IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps> =
+      typia.validate<IAutoBeInterfaceSchemaContentReviewApplication.IProps>(
+        next,
+      );
     if (result.success === false) {
       fulfillJsonSchemaErrorMessages(result.errors);
       return result;
@@ -171,25 +188,31 @@ function createController<Model extends ILlmSchema.Model>(props: {
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Reviewer",
+    name: "ContentReviewer",
     application,
     execute: {
       review: (input) => {
         props.pointer.value = input;
       },
-    } satisfies IAutoBeInterfaceSchemasReviewApplication,
+    } satisfies IAutoBeInterfaceSchemaContentReviewApplication,
   };
 }
 
 const collection = {
   chatgpt: (validate: Validator) =>
-    typia.llm.application<IAutoBeInterfaceSchemasReviewApplication, "chatgpt">({
+    typia.llm.application<
+      IAutoBeInterfaceSchemaContentReviewApplication,
+      "chatgpt"
+    >({
       validate: {
         review: validate,
       },
     }),
   claude: (validate: Validator) =>
-    typia.llm.application<IAutoBeInterfaceSchemasReviewApplication, "claude">({
+    typia.llm.application<
+      IAutoBeInterfaceSchemaContentReviewApplication,
+      "claude"
+    >({
       validate: {
         review: validate,
       },
@@ -198,9 +221,4 @@ const collection = {
 
 type Validator = (
   input: unknown,
-) => IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps>;
-
-export interface IProgress {
-  total: number;
-  completed: number;
-}
+) => IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps>;

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeInterfaceSchemasEvent,
+  AutoBeInterfaceSchemaEvent,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
@@ -59,13 +59,18 @@ export async function orchestrateInterfaceSchemas<
   };
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
+      const operations: AutoBeOpenApi.IOperation[] = props.operations.filter(
+        (op) =>
+          (op.requestBody && it.includes(op.requestBody.typeName)) ||
+          (op.responseBody && it.includes(op.responseBody.typeName)),
+      );
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
         await divideAndConquer(ctx, {
-          instruction: props.instruction,
-          operations: props.operations,
-          typeNames: it,
+          operations,
           progress,
           promptCacheKey,
+          typeNames: it,
+          instruction: props.instruction,
         });
       return row;
     }),
@@ -129,9 +134,12 @@ async function process<Model extends ILlmSchema.Model>(
     value: null,
   };
   const { tokenUsage } = await ctx.conversate({
-    source: "interfaceSchemas",
+    source: "interfaceSchema",
     histories: transformInterfaceSchemaHistories({
       state: ctx.state(),
+      typeNames: Array.from(
+        new Set([...props.remained, ...Object.keys(props.oldbie)]),
+      ),
       operations: props.operations,
       instruction: props.instruction,
     }),
@@ -154,7 +162,7 @@ async function process<Model extends ILlmSchema.Model>(
       too.
 
       ${Array.from(props.remained)
-        .map((k) => `      - \`${k}\``)
+        .map((k) => `- \`${k}\``)
         .join("\n")}${
         already.length !== 0
           ? StringUtil.trim`
@@ -176,7 +184,7 @@ async function process<Model extends ILlmSchema.Model>(
     }) as AutoBeOpenApi.IComponents
   ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
   ctx.dispatch({
-    type: "interfaceSchemas",
+    type: "interfaceSchema",
     id: v7(),
     schemas,
     tokenUsage,
@@ -186,7 +194,7 @@ async function process<Model extends ILlmSchema.Model>(
     ).length),
     step: ctx.state().prisma?.step ?? 0,
     created_at: new Date().toISOString(),
-  } satisfies AutoBeInterfaceSchemasEvent);
+  } satisfies AutoBeInterfaceSchemaEvent);
   return schemas;
 }
 

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

@@ -86,7 +86,11 @@ export namespace IAutoBeInterfaceOperationApplication {
    * }
    * ```
    */
-  export interface IOperation extends AutoBeOpenApi.IEndpoint {
+  export interface IOperation
+    extends Omit<
+      AutoBeOpenApi.IEndpoint,
+      "authorizationActor" | "prerequisites"
+    > {
     /**
      * Specification of the API operation.
      *
@@ -341,58 +345,58 @@ export namespace IAutoBeInterfaceOperationApplication {
     name: string & CamelCasePattern;
 
     /**
-     * Authorization roles required to access this API operation.
+     * Authorization actors required to access this API operation.
      *
-     * This field specifies which user roles are allowed to access this
-     * endpoint. Multiple roles can be specified to allow different types of
+     * This field specifies which user actors are allowed to access this
+     * endpoint. Multiple actors can be specified to allow different types of
      * users to access the same endpoint.
      *
-     * ## ⚠️ CRITICAL: Role Multiplication Effect
+     * ## ⚠️ CRITICAL: Actor Multiplication Effect
      *
-     * **EACH ROLE IN THIS ARRAY GENERATES A SEPARATE ENDPOINT**
+     * **EACH ACTOR IN THIS ARRAY GENERATES A SEPARATE ENDPOINT**
      *
      * - If you specify `["admin", "moderator", "member"]`, this creates 3
      *   separate endpoints
-     * - Total generated endpoints = operations × average roles.length
-     * - Example: 100 operations with 3 roles each = 300 actual endpoints
+     * - Total generated endpoints = operations × average actors.length
+     * - Example: 100 operations with 3 actors each = 300 actual endpoints
      *
      * ## 🔴 AVOID OVER-GENERATION
      *
-     * **DO NOT create role-specific endpoints when a public endpoint would
+     * **DO NOT create actor-specific endpoints when a public endpoint would
      * suffice:**
      *
      * - ❌ BAD: Separate GET endpoints for admin, member, moderator to view the
      *   same public data
-     * - ✅ GOOD: Single public endpoint `[]` with role-based filtering in business
+     * - ✅ GOOD: Single public endpoint `[]` with actor-based filtering in business
      *   logic
      *
-     * **DO NOT enumerate all possible roles when the Prisma schema uses a
+     * **DO NOT enumerate all possible actors when the Prisma schema uses a
      * single User table:**
      *
      * - If Prisma has a User table with role/permission fields, you likely only
      *   need `["user"]`
      * - Avoid listing `["admin", "seller", "buyer", "moderator", ...]`
      *   unnecessarily
-     * - The actual role checking happens in business logic, not at the endpoint
+     * - The actual actor checking happens in business logic, not at the endpoint
      *   level
      *
      * ## Naming Convention
      *
-     * DO: Use camelCase for all role names.
+     * DO: Use camelCase for all actor names.
      *
      * ## Important Guidelines
      *
      * - Set to empty array `[]` for public endpoints that require no
      *   authentication
-     * - Set to array with role strings for role-restricted endpoints
-     * - **MINIMIZE the number of roles per endpoint to prevent explosion**
-     * - Consider if the endpoint can be public with role-based filtering instead
-     * - The role names match exactly with the user type/role defined in the
+     * - Set to array with actor strings for actor-restricted endpoints
+     * - **MINIMIZE the number of actors per endpoint to prevent explosion**
+     * - Consider if the endpoint can be public with actor-based filtering instead
+     * - The actor names match exactly with the user type/actor defined in the
      *   database
      * - This will be used by the Realize Agent to generate appropriate decorator
      *   and authorization logic in the provider functions
      * - The controller will apply the corresponding authentication decorator
-     *   based on these roles
+     *   based on these actors
      *
      * ## Examples
      *
@@ -410,17 +414,17 @@ export namespace IAutoBeInterfaceOperationApplication {
      *
      * 1. **Start with public `[]` for all read operations** unless sensitive data
      *    is involved
-     * 2. **Use single role `["user"]` for authenticated operations** and handle
+     * 2. **Use single actor `["user"]` for authenticated operations** and handle
      *    permissions in business logic
-     * 3. **Only use multiple roles when absolutely necessary** for different
+     * 3. **Only use multiple actors when absolutely necessary** for different
      *    business logic paths
-     * 4. **Remember: Fewer roles = Fewer endpoints = Better performance and
+     * 4. **Remember: Fewer actors = Fewer endpoints = Better performance and
      *    maintainability**
      *
      * Note: The actual authentication/authorization implementation will be
      * handled by decorators at the controller level, and the provider function
      * will receive the authenticated user object with the appropriate type.
      */
-    authorizationRoles: Array<string & CamelCasePattern & tags.MinLength<1>>;
+    authorizationActors: Array<string & CamelCasePattern & tags.MinLength<1>>;
   }
 }

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

@@ -18,8 +18,8 @@ export interface IAutoBeInterfaceOperationsReviewApplication {
    * process containing review findings and improvement plans, plus the final
    * production-ready operations with all critical issues resolved.
    *
-   * @param input Properties containing the thinking process (review & plan)
-   *   and the enhanced operations content
+   * @param input Properties containing the thinking process (review & plan) and
+   *   the enhanced operations content
    */
   reviewOperations(
     input: IAutoBeInterfaceOperationsReviewApplication.IProps,
@@ -32,7 +32,7 @@ export namespace IAutoBeInterfaceOperationsReviewApplication {
    *
    * Contains both the input operations to be reviewed and the outputs generated
    * by the Interface Operations Review Agent, which will be published as part
-   * of the AutoBeInterfaceOperationsReviewEvent.
+   * of the AutoBeInterfaceOperationReviewEvent.
    */
   export interface IProps {
     /**
@@ -70,10 +70,10 @@ export namespace IAutoBeInterfaceOperationsReviewApplication {
   /**
    * Structured thinking process for comprehensive API operation review.
    *
-   * Combines analytical review findings with actionable improvement planning
-   * to guide the systematic enhancement of API operations. This thinking
-   * structure ensures all aspects of API quality are evaluated and addressed
-   * before producing the final operations.
+   * Combines analytical review findings with actionable improvement planning to
+   * guide the systematic enhancement of API operations. This thinking structure
+   * ensures all aspects of API quality are evaluated and addressed before
+   * producing the final operations.
    */
   export interface IThink {
     /**

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

@@ -0,0 +1,108 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export interface IAutoBeInterfaceSchemaContentReviewApplication {
+  /**
+   * Reviews and validates DTO content completeness and consistency in OpenAPI
+   * schemas.
+   *
+   * This specialized content review function focuses exclusively on ensuring
+   * DTOs accurately and completely represent their business entities. It
+   * validates field completeness, type accuracy, required field settings, and
+   * documentation quality.
+   *
+   * The review process validates and corrects:
+   *
+   * - Field completeness against Prisma schema
+   * - Data type accuracy (Prisma to OpenAPI type mappings)
+   * - Required field arrays matching Prisma nullability
+   * - Description quality and comprehensiveness
+   * - Consistency across DTO variants (IEntity, ICreate, IUpdate, ISummary)
+   * - Missing variant detection and creation
+   *
+   * @param props Content review results including completeness issues found,
+   *   fixes applied, and modified schemas
+   */
+  review: (
+    props: IAutoBeInterfaceSchemaContentReviewApplication.IProps,
+  ) => void;
+}
+
+export namespace IAutoBeInterfaceSchemaContentReviewApplication {
+  /**
+   * Output structure for the content review function.
+   *
+   * Contains the content analysis, completeness fixes, and schemas modified for
+   * content quality during the validation process.
+   */
+  export interface IProps {
+    /** Content analysis and completeness planning information. */
+    think: IThink;
+
+    /**
+     * Modified schemas resulting from content and completeness fixes.
+     *
+     * Contains ONLY the schemas that were modified for content reasons during
+     * review. This includes both modified existing schemas and newly created
+     * variant schemas.
+     *
+     * Content modifications include:
+     *
+     * - Adding missing fields from Prisma schema
+     * - Correcting data type mappings
+     * - Fixing required field arrays
+     * - Enhancing or adding descriptions
+     * - Creating missing variant types (ISummary, IUpdate, etc.)
+     * - Ensuring cross-variant consistency
+     *
+     * Return empty object {} when all content is already complete and accurate,
+     * requiring no modifications.
+     */
+    content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  }
+
+  export interface IThink {
+    /**
+     * Content completeness and quality findings from the review process.
+     *
+     * Documents all content issues discovered during validation, categorized by
+     * type: field completeness, type accuracy, required fields, descriptions,
+     * variant consistency, and missing variants. Each issue includes the
+     * affected schema and specific problem identified.
+     *
+     * Common issues documented:
+     *
+     * - Field Completeness: Missing fields that exist in Prisma schema
+     * - Type Accuracy: Incorrect type mappings (e.g., Decimal as string)
+     * - Required Fields: Misaligned with Prisma nullable settings
+     * - Description Quality: Missing or inadequate descriptions
+     * - Variant Consistency: Same field with different types across variants
+     * - Missing Variants: Required DTO variants not present
+     *
+     * Should state "No content or completeness issues found." when all schemas
+     * have complete and accurate content.
+     */
+    review: string;
+
+    /**
+     * Content corrections and completeness fixes applied during review.
+     *
+     * Lists all content modifications implemented, organized by fix type:
+     * fields added, types corrected, required arrays fixed, descriptions
+     * enhanced, consistency fixes, and variants created. Documents both field-
+     * level changes and schema-level additions.
+     *
+     * Typical fixes documented:
+     *
+     * - Fields added to match Prisma schema
+     * - Type mappings corrected (Int→integer, Decimal→number)
+     * - Required arrays aligned with nullability
+     * - Descriptions added or enhanced for clarity
+     * - Variant consistency issues resolved
+     * - Missing variants created with appropriate fields
+     *
+     * Should state "No content issues require fixes. All DTOs are complete and
+     * consistent." when no content modifications were necessary.
+     */
+    plan: string;
+  }
+}