@autobe/agent 0.25.6 → 0.26.0

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

@@ -0,0 +1,104 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export interface IAutoBeInterfaceSchemaRelationReviewApplication {
+  /**
+   * Reviews and validates DTO relations and structural patterns in OpenAPI
+   * schemas.
+   *
+   * This specialized relation review function focuses exclusively on data
+   * relations, foreign key transformations, and structural integrity. It
+   * ensures proper modeling of business domains while preventing circular
+   * references and enabling efficient code generation.
+   *
+   * The review process validates and corrects:
+   *
+   * - Relation classifications (Composition vs Association vs Aggregation)
+   * - Foreign key to object transformations in response DTOs
+   * - Actor reversal violations (e.g., User containing articles array)
+   * - Inline object extractions to named types with $ref
+   * - IInvert pattern applications for alternative perspectives
+   *
+   * @param props Relation review results including violations found, fixes
+   *   applied, and modified schemas
+   */
+  review: (
+    props: IAutoBeInterfaceSchemaRelationReviewApplication.IProps,
+  ) => void;
+}
+
+export namespace IAutoBeInterfaceSchemaRelationReviewApplication {
+  /**
+   * Output structure for the relation review function.
+   *
+   * Contains the relation analysis, structural fixes, and schemas modified for
+   * proper relations during the validation process.
+   */
+  export interface IProps {
+    /** Relation analysis and structural planning information. */
+    think: IThink;
+
+    /**
+     * Modified schemas resulting from relation and structural fixes.
+     *
+     * Contains ONLY the schemas that were modified for relation or structural
+     * reasons during review. This includes both modified existing schemas and
+     * newly created schemas (extracted types, IInvert types).
+     *
+     * Relation modifications include:
+     *
+     * - Extracting inline objects to named types with $ref
+     * - Transforming foreign keys to object references
+     * - Removing incorrect reverse relations
+     * - Creating new IInvert types for alternative views
+     * - Correcting relation types (composition/association/aggregation)
+     *
+     * Return empty object {} when all relations are already correct and no
+     * structural fixes were needed.
+     */
+    content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  }
+
+  export interface IThink {
+    /**
+     * Relation and structural violation findings from the review process.
+     *
+     * Documents all relation issues discovered during validation, categorized
+     * by severity and type. Each violation includes the affected schema,
+     * specific relation problem, and theoretical justification.
+     *
+     * Common violations documented:
+     *
+     * - CRITICAL: Inline object types instead of named types with $ref
+     * - CRITICAL: Actor reversal violations (User.articles[], Seller.sales[])
+     * - HIGH: Raw foreign keys instead of object references
+     * - HIGH: Wrong relation types (event-driven data as composition)
+     * - MEDIUM: Missing IInvert types for independent child views
+     * - LOW: Naming convention violations (plural instead of singular)
+     *
+     * Should state "No relation or structure issues found." when all schemas
+     * have correct relations.
+     */
+    review: string;
+
+    /**
+     * Relation corrections and structural fixes applied during review.
+     *
+     * Lists all relation modifications implemented, organized by fix type and
+     * impact. Documents both schemas modified and new schemas created during
+     * the fix process.
+     *
+     * Typical fixes documented:
+     *
+     * - Inline objects extracted to named types
+     * - Foreign keys transformed to object references
+     * - Actor reversal arrays removed with API endpoint suggestions
+     * - IInvert types created with parent context
+     * - Relation types corrected based on lifecycle analysis
+     * - Naming conventions standardized
+     *
+     * Should state "No relation issues require fixes. All relations are
+     * properly structured." when no modifications were necessary.
+     */
+    plan: string;
+  }
+}

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

@@ -0,0 +1,45 @@
+import { AutoBeInterfaceSchemaRefactor } from "@autobe/interface";
+
+export interface IAutoBeInterfaceSchemaRenameApplication {
+  /**
+   * Analyze DTO type names and identify naming violations.
+   *
+   * This method examines existing DTO type names to detect violations of the
+   * CRITICAL naming rule: ALL words from the Prisma table name MUST be
+   * preserved in the DTO type name. Omitting intermediate words breaks
+   * type-to-table traceability and causes system failures.
+   *
+   * The method receives a list of Prisma table names and current DTO type
+   * names, then identifies which type names incorrectly omit service prefixes
+   * or intermediate components from their corresponding table names.
+   *
+   * @param props Properties containing refactoring operations to fix naming
+   *   violations.
+   */
+  rename(props: IAutoBeInterfaceSchemaRenameApplication.IProps): void;
+}
+export namespace IAutoBeInterfaceSchemaRenameApplication {
+  export interface IProps {
+    /**
+     * List of refactoring operations to rename incorrectly named DTO types.
+     *
+     * Each refactor specifies:
+     *
+     * - `from`: The current INCORRECT type name (e.g., "ISale", "IBbsComment")
+     * - `to`: The CORRECT type name with all components preserved (e.g.,
+     *   "IShoppingSale", "IBbsArticleComment")
+     *
+     * IMPORTANT: Only include type names that violate the naming rules. If a
+     * type name correctly preserves all components from the table name, do NOT
+     * include it in the refactors list.
+     *
+     * The orchestrator will automatically handle:
+     *
+     * - Renaming the base type (e.g., ISale → IShoppingSale)
+     * - Renaming all variants (e.g., ISale.ICreate → IShoppingSale.ICreate)
+     * - Renaming page types (e.g., IPageISale → IPageIShoppingSale)
+     * - Updating all $ref references throughout the OpenAPI document
+     */
+    refactors: AutoBeInterfaceSchemaRefactor[];
+  }
+}

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

@@ -0,0 +1,99 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export interface IAutoBeInterfaceSchemaSecurityReviewApplication {
+  /**
+   * Reviews and validates OpenAPI schema definitions for security compliance.
+   *
+   * This specialized security review function focuses exclusively on
+   * authentication boundaries, data protection, and system integrity. It
+   * enforces strict security policies to prevent authentication bypass, data
+   * exposure, and unauthorized access.
+   *
+   * The review process identifies and removes:
+   *
+   * - Authentication context fields in request DTOs (e.g., bbs_member_id)
+   * - Password and token fields in response DTOs
+   * - System-managed fields in request DTOs
+   * - Phantom fields that don't exist in Prisma schema
+   *
+   * @param props Security review results including violations found, fixes
+   *   applied, and modified schemas
+   */
+  review: (
+    props: IAutoBeInterfaceSchemaSecurityReviewApplication.IProps,
+  ) => void;
+}
+
+export namespace IAutoBeInterfaceSchemaSecurityReviewApplication {
+  /**
+   * Output structure for the security review function.
+   *
+   * Contains the security analysis, remediation actions, and schemas modified
+   * for security compliance during the validation process.
+   */
+  export interface IProps {
+    /** Security analysis and remediation planning information. */
+    think: IThink;
+
+    /**
+     * Modified schemas resulting from security fixes.
+     *
+     * Contains ONLY the schemas that were modified for security reasons during
+     * review. This focused output enables precise tracking of security-related
+     * changes.
+     *
+     * Security modifications include:
+     *
+     * - Removing authentication context fields (user_id, session_id, etc.)
+     * - Removing password/token fields from responses
+     * - Removing system-managed fields from requests
+     * - Removing phantom fields not in Prisma schema
+     *
+     * Return empty object {} when all schemas are already secure and no
+     * security fixes were needed.
+     */
+    content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  }
+
+  export interface IThink {
+    /**
+     * Security violation findings from the review process.
+     *
+     * Documents all security issues discovered during validation, categorized
+     * by severity level (CRITICAL, HIGH, MEDIUM, LOW). Each violation includes
+     * the affected schema name, field name, and specific security rule
+     * violated.
+     *
+     * Common violations documented:
+     *
+     * - CRITICAL: Authentication context in requests (bbs_member_id, session_id)
+     * - CRITICAL: Password/token exposure in responses
+     * - CRITICAL: Phantom fields not existing in Prisma schema
+     * - HIGH: System-managed fields in requests
+     * - HIGH: Immutable ownership fields in updates
+     *
+     * Should state "No security violations found." when all schemas pass
+     * security validation.
+     */
+    review: string;
+
+    /**
+     * Security remediation actions applied to fix identified violations.
+     *
+     * Lists all security fixes implemented during the review process, organized
+     * by fix type and priority. Each fix documents which field was removed or
+     * modified and from which schema.
+     *
+     * Typical fixes documented:
+     *
+     * - Authentication context fields removed from request DTOs
+     * - Sensitive data removed from response DTOs
+     * - Phantom fields deleted to match Prisma schema
+     * - System fields removed from client-controllable DTOs
+     *
+     * Should state "No security issues require fixes. All schemas are secure."
+     * when no security modifications were necessary.
+     */
+    plan: string;
+  }
+}

package/src/orchestrate/interface/utils/JsonSchemaFactory.ts

@@ -1,6 +1,6 @@
 import { AutoBeOpenApi, AutoBePrisma } from "@autobe/interface";
 import { AutoBeOpenApiTypeChecker, StringUtil } from "@autobe/utils";
-import { OpenApiTypeChecker } from "@samchon/openapi";
+import { OpenApi, OpenApiTypeChecker } from "@samchon/openapi";
 import typia, { tags } from "typia";
 
 export namespace JsonSchemaFactory {
@@ -53,6 +53,7 @@ export namespace JsonSchemaFactory {
     application: AutoBePrisma.IApplication;
   }): void => {
     removeUnused(props.document);
+    removeDuplicated(props.document);
     fixTimestamps(props);
   };
 
@@ -84,6 +85,47 @@ export namespace JsonSchemaFactory {
       if (used.has(key) === false) delete document.components.schemas[key];
   };
 
+  const removeDuplicated = (document: AutoBeOpenApi.IDocument): void => {
+    // gather duplicated schemas
+    const correct: Map<string, string> = new Map();
+    for (const key of Object.keys(document.components.schemas)) {
+      if (key.includes(".") === false) continue;
+      const dotRemoved: string = key.replace(".", "");
+      if (document.components.schemas[dotRemoved] === undefined) continue;
+      correct.set(dotRemoved, key);
+    }
+
+    // fix operations' references
+    for (const op of document.operations) {
+      if (op.requestBody && correct.has(op.requestBody.typeName))
+        op.requestBody.typeName = correct.get(op.requestBody.typeName)!;
+      if (op.responseBody && correct.has(op.responseBody.typeName))
+        op.responseBody.typeName = correct.get(op.responseBody.typeName)!;
+    }
+
+    // fix schemas' references
+    const $refChangers: Map<OpenApi.IJsonSchema, () => void> = new Map();
+    for (const value of Object.values(document.components.schemas))
+      OpenApiTypeChecker.visit({
+        components: { schemas: document.components.schemas },
+        schema: value,
+        closure: (next) => {
+          if (OpenApiTypeChecker.isReference(next) === false) return;
+          const x: string = next.$ref.split("/").pop()!;
+          const y: string | undefined = correct.get(x);
+          if (y === undefined) return;
+          $refChangers.set(
+            next,
+            () => (next.$ref = `#/components/schemas/${y}`),
+          );
+        },
+      });
+    for (const fn of $refChangers.values()) fn();
+
+    // remove duplicated schemas
+    for (const key of correct.keys()) delete document.components.schemas[key];
+  };
+
   const fixTimestamps = (props: {
     document: AutoBeOpenApi.IDocument;
     application: AutoBePrisma.IApplication;
@@ -220,8 +262,8 @@ namespace IPage {
  * 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
+ * detects authorization actors in the requirements analysis phase. It provides
+ * a standard format for JWT-based authentication across the generated backend
  * applications.
  */
 interface IAuthorizationToken {

package/src/orchestrate/interface/utils/JsonSchemaValidator.ts

@@ -13,6 +13,7 @@ export namespace JsonSchemaValidator {
   export const validateSchemas = (props: IProps): void => {
     validateAuthorization(props);
     validatePrismaSchema(props.errors);
+    validateRecursive(props);
     for (const key of Object.keys(props.schemas))
       validateKey({
         errors: props.errors,
@@ -174,4 +175,113 @@ export namespace JsonSchemaValidator {
       `;
     }
   };
+
+  const validateRecursive = (props: IProps): void => {
+    for (const [key, value] of Object.entries(props.schemas)) {
+      const report = (description: string) =>
+        props.errors.push({
+          path: `${props.path}[${JSON.stringify(key)}]`,
+          expected: "Non-infinite recursive schema definition",
+          value,
+          description,
+        });
+      if (
+        AutoBeOpenApiTypeChecker.isReference(value) &&
+        value.$ref === `#/components/schemas/${key}`
+      )
+        report(StringUtil.trim`
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          type ${key} = ${key};
+          \`\`\`
+
+          This is an infinite recursive type definition that cannot exist in any
+          programming language. A type cannot be defined as itself - this creates
+          a circular definition with no base case, making the type impossible to
+          instantiate or validate.
+
+          If you need tree or graph structures, use explicit relationships with
+          ID references (e.g., parentId: string) instead of recursive type definitions.
+          Remove the self-reference and redesign the schema at the next time.
+        `);
+      else if (
+        AutoBeOpenApiTypeChecker.isArray(value) &&
+        AutoBeOpenApiTypeChecker.isReference(value.items) &&
+        value.items.$ref === `#/components/schemas/${key}`
+      )
+        report(StringUtil.trim`
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          type ${key} = Array<${key}>;
+          \`\`\`
+
+          This is an infinite recursive array type that cannot exist in any
+          programming language. An array of itself creates a circular definition
+          with no base case, making the type impossible to instantiate or validate.
+
+          If you need nested structures, define explicit depth levels with separate
+          types, or use parent-child relationships with ID references.
+          Remove the self-reference and redesign the schema at the next time.
+        `);
+      else if (
+        AutoBeOpenApiTypeChecker.isOneOf(value) &&
+        value.oneOf.some(
+          (v) =>
+            AutoBeOpenApiTypeChecker.isReference(v) &&
+            v.$ref === `#/components/schemas/${key}`,
+        ) === true
+      )
+        report(StringUtil.trim`
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          type ${key} = ${key} | ...;
+          \`\`\`
+
+          This is an infinite recursive union type that cannot exist in any
+          programming language. A union that includes itself as a variant creates
+          a circular definition with no base case, making the type impossible to
+          instantiate or validate.
+
+          If you need polymorphic hierarchies, define separate concrete types for
+          each variant without including the union type itself as a variant.
+          Remove the self-reference and redesign the schema at the next time.
+        `);
+      else if (
+        AutoBeOpenApiTypeChecker.isObject(value) &&
+        value.properties &&
+        value.required &&
+        Object.entries(value.properties).some(
+          ([k, v]) =>
+            AutoBeOpenApiTypeChecker.isReference(v) &&
+            v.$ref === `#/components/schemas/${key}` &&
+            value.required.includes(k),
+        )
+      )
+        report(StringUtil.trim`
+          You have defined a nonsensible type like below:
+
+          \`\`\`typescript
+          interface ${key} {
+            someProperty: ${key}; // required, non-nullable
+          }
+          \`\`\`
+
+          This is an infinite recursive object type that cannot exist in any
+          programming language. A required non-nullable property referencing its
+          own type creates a circular definition with no base case, making the
+          type impossible to instantiate.
+
+          To create an instance of ${key}, you would need an instance of ${key},
+          which requires another instance of ${key}, infinitely. This is logically
+          impossible.
+
+          If you need parent-child or graph relationships, make the self-referencing
+          property either nullable or optional, or use ID references (e.g., parentId: string).
+          Remove the required self-reference and redesign the schema at the next time.
+        `);
+    }
+  };
 }

package/src/orchestrate/interface/utils/OperationValidator.ts

@@ -14,7 +14,7 @@ export namespace OperationValidator {
     operations: Array<
       Omit<
         AutoBeOpenApi.IOperation,
-        "authorizationRole" | "authorizationType" | "prerequisites"
+        "authorizationActor" | "authorizationType" | "prerequisites"
       >
     >;
   }): void => {

package/src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts

@@ -65,19 +65,19 @@ export const transformPrismaComponentsHistories = (
         - \`mv_shopping_daily_stats\`
         
         ${
-          state.analyze.roles.length > 0
+          state.analyze.actors.length > 0
             ? StringUtil.trim`
-                ## User Role Handling
-                
-                The Requirement Analysis Report contains the following user roles: ${state.analyze.roles.join(", ")}
-                
-                **Do not normalize** user roles into a single table.
-                Instead, create separate tables for each distinct role mentioned in the requirements.
-                
-                Create separate tables for each role:
-                
-                ${state.analyze.roles
-                  .map((role) => `- ${props.prefix}_${role.name.toLowerCase()}`)
+                ## User Actor Handling
+
+                The Requirement Analysis Report contains the following user actors: ${state.analyze.actors.join(", ")}
+
+                **Do not normalize** user actors into a single table.
+                Instead, create separate tables for each distinct actor mentioned in the requirements.
+
+                Create separate tables for each actor:
+
+                ${state.analyze.actors
+                  .map((actor) => `- ${props.prefix}_${actor.name.toLowerCase()}`)
                   .join("\n")}
               `
             : ""

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -2,13 +2,13 @@ import {
   AutoBeAssistantMessageHistory,
   AutoBePrisma,
   AutoBePrismaCompleteEvent,
-  AutoBePrismaComponentsEvent,
+  AutoBePrismaComponentEvent,
   AutoBePrismaHistory,
   AutoBePrismaReviewEvent,
   IAutoBeCompiler,
   IAutoBePrismaValidation,
 } from "@autobe/interface";
-import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
+import { AutoBePrismaSchemaEvent } from "@autobe/interface/src/events/AutoBePrismaSchemaEvent";
 import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
@@ -44,12 +44,12 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   });
 
   // COMPONENTS
-  const componentEvent: AutoBePrismaComponentsEvent =
+  const componentEvent: AutoBePrismaComponentEvent =
     await orchestratePrismaComponents(ctx, props.instruction);
   ctx.dispatch(componentEvent);
 
   // CONSTRUCT AST DATA
-  const schemaEvents: AutoBePrismaSchemasEvent[] =
+  const schemaEvents: AutoBePrismaSchemaEvent[] =
     await orchestratePrismaSchemas(
       ctx,
       props.instruction,

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -1,5 +1,5 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
+import { AutoBePrismaComponentEvent } from "@autobe/interface/src/events/AutoBePrismaComponentEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -16,14 +16,14 @@ export async function orchestratePrismaComponents<
   ctx: AutoBeContext<Model>,
   instruction: string,
   message: string = "Design database from the given requirement analysis documents.",
-): Promise<AutoBePrismaComponentsEvent> {
+): Promise<AutoBePrismaComponentEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBePrismaComponentApplication.IProps | null> = {
     value: null,
   };
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
   const { tokenUsage } = await ctx.conversate({
-    source: "prismaComponents",
+    source: "prismaComponent",
     histories: transformPrismaComponentsHistories(ctx.state(), {
       prefix,
       instruction,
@@ -40,7 +40,7 @@ export async function orchestratePrismaComponents<
   if (pointer.value === null)
     throw new Error("Failed to extract files and tables."); // unreachable
   return {
-    type: "prismaComponents",
+    type: "prismaComponent",
     id: v7(),
     created_at: start.toISOString(),
     thinking: pointer.value.thinking,

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import { AutoBePrisma } from "@autobe/interface";
-import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
+import { AutoBePrismaSchemaEvent } from "@autobe/interface/src/events/AutoBePrismaSchemaEvent";
 import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
@@ -17,7 +17,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   instruction: string,
   componentList: AutoBePrisma.IComponent[],
-): Promise<AutoBePrismaSchemasEvent[]> {
+): Promise<AutoBePrismaSchemaEvent[]> {
   const start: Date = new Date();
   const total: number = componentList
     .map((c) => c.tables.length)
@@ -29,7 +29,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
         .filter((y) => component !== y)
         .map((c) => c.tables)
         .flat();
-      const event: AutoBePrismaSchemasEvent = await process(ctx, {
+      const event: AutoBePrismaSchemaEvent = await process(ctx, {
         instruction,
         component,
         otherTables,
@@ -55,12 +55,12 @@ async function process<Model extends ILlmSchema.Model>(
     completed: IPointer<number>;
     promptCacheKey: string;
   },
-): Promise<AutoBePrismaSchemasEvent> {
+): Promise<AutoBePrismaSchemaEvent> {
   const pointer: IPointer<IAutoBePrismaSchemaApplication.IProps | null> = {
     value: null,
   };
   const { tokenUsage } = await ctx.conversate({
-    source: "prismaSchemas",
+    source: "prismaSchema",
     histories: transformPrismaSchemaHistories({
       analysis:
         ctx
@@ -87,7 +87,7 @@ async function process<Model extends ILlmSchema.Model>(
   if (pointer.value === null)
     throw new Error("Unreachable code: Prisma Schema not generated");
   return {
-    type: "prismaSchemas",
+    type: "prismaSchema",
     id: v7(),
     created_at: props.start.toISOString(),
     plan: pointer.value.plan,
@@ -101,7 +101,7 @@ async function process<Model extends ILlmSchema.Model>(
     completed: (props.completed.value += props.component.tables.length),
     total: props.total,
     step: ctx.state().analyze?.step ?? 0,
-  } satisfies AutoBePrismaSchemasEvent;
+  } satisfies AutoBePrismaSchemaEvent;
 }
 
 function createController<Model extends ILlmSchema.Model>(

package/src/orchestrate/realize/histories/transformRealizeAuthorization.ts

@@ -1,5 +1,5 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeAnalyzeRole } from "@autobe/interface";
+import { AutoBeAnalyzeActor } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
@@ -11,7 +11,7 @@ export const transformRealizeAuthorizationHistories = <
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  role: AutoBeAnalyzeRole,
+  actor: AutoBeAnalyzeActor,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
@@ -27,9 +27,10 @@ export const transformRealizeAuthorizationHistories = <
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: StringUtil.trim`
-        ## Role
+        ## Actor
+        
         \`\`\`json
-        ${JSON.stringify(role)}
+        ${JSON.stringify(actor)}
         \`\`\`
 
         ## Prisma Schema
@@ -42,9 +43,9 @@ export const transformRealizeAuthorizationHistories = <
 
         Please follow this naming convention for the authorization components:
 
-        - Provider Name: ${role.name}Authorize (e.g. ${role.name}Authorize)
-        - Decorator Name: ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Auth (e.g. ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Auth)
-        - Payload Name: ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Payload (e.g. ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Payload)
+        - Provider Name: ${actor.name}Authorize (e.g. ${actor.name}Authorize)
+        - Decorator Name: ${actor.name.charAt(0).toUpperCase() + actor.name.slice(1)}Auth (e.g. ${actor.name.charAt(0).toUpperCase() + actor.name.slice(1)}Auth)
+        - Payload Name: ${actor.name.charAt(0).toUpperCase() + actor.name.slice(1)}Payload (e.g. ${actor.name.charAt(0).toUpperCase() + actor.name.slice(1)}Payload)
       `,
     },
   ];

package/src/orchestrate/realize/histories/transformRealizeAuthorizationCorrectHistories.ts

@@ -57,7 +57,7 @@ export const transformRealizeAuthorizationCorrectHistories = <
             name: auth.payload.name,
             content: auth.payload.content,
           },
-        } satisfies Omit<AutoBeRealizeAuthorization, "role">)}
+        } satisfies Omit<AutoBeRealizeAuthorization, "actor">)}
         \`\`\`
 
         ## Prisma Schema
@@ -86,9 +86,9 @@ export const transformRealizeAuthorizationCorrectHistories = <
 
         Please follow this naming convention for the authorization components:
 
-        - Provider Name: ${auth.role.name.toLowerCase()}Authorize (e.g. ${auth.role.name.toLowerCase()}Authorize)
-        - Decorator Name: ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Auth (e.g. ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Auth)
-        - Payload Name: ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Payload (e.g. ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Payload)
+        - Provider Name: ${auth.actor.name.toLowerCase()}Authorize (e.g. ${auth.actor.name.toLowerCase()}Authorize)
+        - Decorator Name: ${auth.actor.name.charAt(0).toUpperCase() + auth.actor.name.slice(1).toLowerCase()}Auth (e.g. ${auth.actor.name.charAt(0).toUpperCase() + auth.actor.name.slice(1).toLowerCase()}Auth)
+        - Payload Name: ${auth.actor.name.charAt(0).toUpperCase() + auth.actor.name.slice(1).toLowerCase()}Payload (e.g. ${auth.actor.name.charAt(0).toUpperCase() + auth.actor.name.slice(1).toLowerCase()}Payload)
       `,
     },
   ];