@autobe/agent 0.18.0 → 0.19.1

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

@@ -23,7 +23,7 @@ export namespace IAutoBeInterfaceOperationApplication {
     /**
      * Array of API operations to generate.
      *
-     * Each operation in this array must include:
+     * Each operation in this array includes:
      *
      * - Specification: Detailed API specification with clear purpose and
      *   functionality
@@ -38,7 +38,7 @@ export namespace IAutoBeInterfaceOperationApplication {
      *   components.schemas
      * - ResponseBody: With typeName referencing appropriate response type
      *
-     * All operations must follow strict quality standards:
+     * All operations follow strict quality standards:
      *
      * 1. Detailed descriptions referencing Prisma schema comments
      * 2. Accurate parameter definitions matching path parameters
@@ -66,11 +66,10 @@ export namespace IAutoBeInterfaceOperationApplication {
    * reason and description fields, making it clear why the API was designed and
    * how it should be used.
    *
-   * All request bodies and responses for this operation must be object types
-   * and must reference named types defined in the components section. The
-   * content-type is always `application/json`. For file upload/download
-   * operations, use `string & tags.Format<"uri">` in the appropriate schema
-   * instead of binary data formats.
+   * DO: Use object types for all request bodies and responses. DO: Reference
+   * named types defined in the components section. DO: Use `application/json`
+   * as the content-type. DO: Use `string & tags.Format<"uri">` in the schema
+   * for file upload/download operations instead of binary data formats.
    *
    * In OpenAPI, this might represent:
    *
@@ -88,7 +87,10 @@ export namespace IAutoBeInterfaceOperationApplication {
    * ```
    */
   export interface IOperation
-    extends Omit<AutoBeOpenApi.IOperation, "authorizationRole"> {
+    extends Omit<
+      AutoBeOpenApi.IOperation,
+      "authorizationRole" | "authorizationType"
+    > {
     /**
      * Authorization roles required to access this API operation.
      *
@@ -96,16 +98,47 @@ export namespace IAutoBeInterfaceOperationApplication {
      * endpoint. Multiple roles can be specified to allow different types of
      * users to access the same endpoint.
      *
+     * ## ⚠️ CRITICAL: Role Multiplication Effect
+     *
+     * **EACH ROLE 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
+     *
+     * ## 🔴 AVOID OVER-GENERATION
+     *
+     * **DO NOT create role-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
+     *   logic
+     *
+     * **DO NOT enumerate all possible roles 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
+     *   level
+     *
      * ## Naming Convention
      *
-     * All role names MUST use camelCase.
+     * DO: Use camelCase for all role names.
      *
      * ## Important Guidelines
      *
      * - Set to empty array `[]` for public endpoints that require no
      *   authentication
      * - Set to array with role strings for role-restricted endpoints
-     * - The role names MUST match exactly with the user type/role defined in the
+     * - **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
      *   database
      * - This will be used by the Realize Agent to generate appropriate decorator
      *   and authorization logic in the provider functions
@@ -114,11 +147,26 @@ export namespace IAutoBeInterfaceOperationApplication {
      *
      * ## Examples
      *
-     * - `[]` - Public endpoint, no authentication required
-     * - `["user"]` - Any authenticated user can access
-     * - `["admin"]` - Only admin users can access
+     * - `[]` - Public endpoint, no authentication required (PREFERRED for read
+     *   operations)
+     * - `["user"]` - Any authenticated user can access (PREFERRED for
+     *   user-specific operations)
+     * - `["admin"]` - Only admin users can access (USE SPARINGLY)
      * - `["admin", "moderator"]` - Both admin and moderator users can access
-     * - `["seller"]` - Only seller users can access
+     *   (AVOID if possible)
+     * - `["seller"]` - Only seller users can access (ONLY if Seller is a separate
+     *   table)
+     *
+     * ## Best Practices
+     *
+     * 1. **Start with public `[]` for all read operations** unless sensitive data
+     *    is involved
+     * 2. **Use single role `["user"]` for authenticated operations** and handle
+     *    permissions in business logic
+     * 3. **Only use multiple roles when absolutely necessary** for different
+     *    business logic paths
+     * 4. **Remember: Fewer roles = 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

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

@@ -97,6 +97,43 @@ export namespace IAutoBeInterfaceOperationsReviewApplication {
      * operations unchanged. These operations are validated and ready for schema
      * generation and subsequent implementation phases.
      */
-    content: AutoBeOpenApi.IOperation[];
+    content: IOperation[];
   }
+
+  /**
+   * Operation of the Restful API.
+   *
+   * This interface defines a single API endpoint with its HTTP {@link method},
+   * {@link path}, {@link parameters path parameters},
+   * {@link requestBody request body}, and {@link responseBody} structure. It
+   * corresponds to an individual operation in the paths section of an OpenAPI
+   * document.
+   *
+   * Each operation requires a detailed explanation of its purpose through the
+   * reason and description fields, making it clear why the API was designed and
+   * how it should be used.
+   *
+   * All request bodies and responses for this operation must be object types
+   * and must reference named types defined in the components section. The
+   * content-type is always `application/json`. For file upload/download
+   * operations, use `string & tags.Format<"uri">` in the appropriate schema
+   * instead of binary data formats.
+   *
+   * In OpenAPI, this might represent:
+   *
+   * ```json
+   * {
+   *   "/shoppings/customers/orders": {
+   *     "post": {
+   *       "description": "Create a new order application from shopping cart...",
+   *       "parameters": [...],
+   *       "requestBody": {...},
+   *       "responses": {...}
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  export interface IOperation
+    extends Omit<AutoBeOpenApi.IOperation, "authorizationType"> {}
 }

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

@@ -14,10 +14,9 @@ export interface IAutoBeInterfaceSchemaApplication {
    * creation. This ensures that the final OpenAPI document has complete type
    * coverage for all operations.
    *
-   * CRITICAL: All schema definitions must follow the established naming
-   * conventions (IEntityName, IEntityName.ICreate, etc.) and must be thoroughly
-   * documented with descriptions that reference the original Prisma schema
-   * comments.
+   * DO: Follow established naming conventions (IEntityName,
+   * IEntityName.ICreate, etc.) DO: Document thoroughly with descriptions that
+   * reference the original Prisma schema comments.
    *
    * @param props Properties containing components to generate.
    */
@@ -25,6 +24,40 @@ export interface IAutoBeInterfaceSchemaApplication {
 }
 export namespace IAutoBeInterfaceSchemaApplication {
   export interface IProps {
+    /**
+     * TypeScript draft code for schema definitions.
+     *
+     * This property contains TypeScript interface definitions that serve as a
+     * preliminary draft before generating the final JSON schema components.
+     * The draft allows for initial design and validation of the schema structure
+     * using TypeScript's type system before converting to OpenAPI/JSON Schema format.
+     *
+     * The draft typically includes:
+     * - Entity interfaces matching the Prisma models
+     * - Operation-specific variants (ICreate, IUpdate, etc.)
+     * - Utility types and enumerations
+     * - Type relationships and constraints
+     *
+     * This TypeScript draft serves as the foundation for the subsequent schema
+     * generation, ensuring type safety and consistency. The final schemas in the
+     * `schemas` property should be derived from and validated against this draft.
+     *
+     * Example draft structure:
+     * ```typescript
+     * interface IUser {
+     *   id: string;
+     *   email: string;
+     *   profile: IUserProfile;
+     * }
+     * 
+     * namespace IUser {
+     *   interface ICreate extends Omit<IUser, "id"> {}
+     *   interface IUpdate extends Partial<ICreate> {}
+     * }
+     * ```
+     */
+    draft: string;
+
     /**
      * Complete set of schema components for the OpenAPI specification.
      *
@@ -32,23 +65,23 @@ export namespace IAutoBeInterfaceSchemaApplication {
      * the system. It is the central repository of all named schema types that
      * will be used throughout the API specification.
      *
-     * CRITICAL REQUIREMENT: All object types MUST be defined as named types in
-     * the components.schemas section. Inline anonymous object definitions are
-     * strictly prohibited.
+     * DO: Define all object types as named types in the components.schemas
+     * section. DO NOT: Use inline anonymous object definitions.
      *
-     * This components object should include:
+     * This components object includes:
      *
      * - Main entity types (IEntityName)
      * - Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)
      * - Container types (IPage<T> for pagination)
      * - Enumeration types
      *
-     * All schema definitions must include detailed descriptions that reference
-     * the original Prisma schema comments and thoroughly document each
-     * property. Every property that references an object must use a $ref to a
-     * named type in the components.schemas section. This applies to all objects
-     * in request bodies, response bodies, and properties that are objects or
-     * arrays of objects.
+     * DO: Include detailed descriptions that reference the original Prisma
+     * schema comments and thoroughly document each property. DO: Use a $ref to
+     * a named type in the components.schemas section for every property that
+     * references an object.
+     *
+     * This applies to all objects in request bodies, response bodies, and
+     * properties that are objects or arrays of objects.
      *
      * Example structure:
      *

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

@@ -32,19 +32,16 @@ export namespace IAutoBeInterfaceSchemasReviewApplication {
     /**
      * Issues and problems found during schema analysis.
      *
-     * IMPORTANT: Only document problems that need fixing. Do NOT include:
-     *
-     * - Positive feedback about what's already correct
-     * - Compliments about well-structured schemas
-     * - Confirmation that certain aspects meet standards
+     * DO: Document only problems that need fixing.
+     * DO NOT: Include positive feedback, compliments, or confirmations
      *
      * Focus exclusively on issues organized by severity:
      *
-     * - CRITICAL: Security vulnerabilities (exposed passwords, missing auth
-     *   boundaries)
-     * - HIGH: Missing required variants, incorrect type mappings
-     * - MEDIUM: Missing format specifications, incomplete relationships
-     * - LOW: Documentation improvements, style consistency
+     * Severity levels:
+     * - Security vulnerabilities (exposed passwords, missing auth boundaries)
+     * - Missing required variants, incorrect type mappings
+     * - Missing format specifications, incomplete relationships
+     * - Documentation improvements, style consistency
      *
      * Each issue must include the specific schema name and what needs to be
      * fixed. If there are no issues at all, simply state: "No issues found."
@@ -70,21 +67,18 @@ export namespace IAutoBeInterfaceSchemasReviewApplication {
     /**
      * Final validated and enhanced schemas ready for production use.
      *
-     * CRITICAL REQUIREMENTS:
-     *
-     * - MUST NEVER be an empty object {}
-     * - MUST contain valid OpenAPI schema definitions
-     * - MUST include all entities that were in the original input
-     * - If original schemas have critical issues, MUST contain fixed versions
-     * - If entity names are wrong, MUST contain renamed correct versions
-     * - If schemas are missing variants, MUST include the created variants
-     *
-     * FORBIDDEN:
+     * DO:
+     * - Include valid OpenAPI schema definitions
+     * - Include all entities that were in the original input
+     * - Provide fixed versions if original schemas have issues
+     * - Rename entities correctly if names are wrong
+     * - Include created variants if schemas are missing them
      *
-     * - Empty object {} will cause all schemas to be deleted
-     * - Returning undefined or null
-     * - Including explanations or excuses in schema descriptions
-     * - Leaving broken schemas unfixed
+     * DO NOT:
+     * - Return an empty object {} (this will delete all schemas)
+     * - Return undefined or null
+     * - Include explanations or excuses in schema descriptions
+     * - Leave broken schemas unfixed
      *
      * When original schemas are beyond repair, recreate them properly based on
      * entity names and context. This field becomes the final schemas used by

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

@@ -0,0 +1,41 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { IValidation } from "typia";
+
+export const validateAuthorizationSchema = (props: {
+  errors: IValidation.IError[];
+  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  path: string;
+}): void => {
+  for (const [key, value] of Object.entries(props.schemas)) {
+    if (!key.endsWith(".IAuthorized")) continue;
+
+    // Check if it's an object type
+    if (!isObjectSchema(value)) {
+      props.errors.push({
+        path: `${props.path}.${key}`,
+        expected: `AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema.IObject>`,
+        value: value,
+        description: `${key} must be an object type for authorization responses`,
+      });
+      continue;
+    }
+
+    // Check if token property exists
+    value.properties ??= {};
+    value.properties["token"] = {
+      $ref: "#/components/schemas/IAuthorizationToken",
+      description: "JWT token information for authentication",
+    } as AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema.IReference>;
+
+    value.required ??= [];
+    if (value.required.includes("token") === false) {
+      value.required.push("token");
+    }
+  }
+};
+
+const isObjectSchema = (
+  schema: AutoBeOpenApi.IJsonSchemaDescriptive,
+): schema is AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema.IObject> => {
+  return "type" in schema && schema.type === "object";
+};

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

@@ -1,4 +1,5 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
+import { NamingConvention } from "typia/lib/utils/NamingConvention";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
@@ -11,18 +12,9 @@ export const transformPrismaComponentsHistories = (
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   if (state.analyze === null)
-    return [
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-          "Requirement analysis is not yet completed.",
-          "Don't call any tool function,",
-          "but say to process the requirement analysis.",
-        ].join(" "),
-      },
-    ];
+    // unreachable
+    throw new Error("Analyze state is not set.");
+  if (prefix) prefix = NamingConvention.snake(prefix);
   return [
     {
       id: v4(),
@@ -50,13 +42,14 @@ export const transformPrismaComponentsHistories = (
         `* Prefix provided by the user: ${prefix}`,
         "",
         "The user wants all database schema (table) names to start with the prefix provided below.",
-        "If the prefix is `null`, it should be ignored.",
-        "If a prefix is provided, all table names **must begin with it**.",
-        "However, if there is a special-purpose prefix like `mv` (for materialized views), it **must precede** the given prefix.",
+        "",
+        "DO: Use the provided prefix for all table names",
+        "DO: Place special-purpose prefixes like `mv` (for materialized views) before the given prefix",
+        "DO NOT: Apply prefix if it is `null`",
         "",
         "## Prefix Example",
         "",
-        "If the prefix is `shopping`, then table names should be like:",
+        "If the prefix is `shopping`, then table names are like:",
         "",
         "* `shopping_sales`",
         "* `shopping_sale_options`",

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -10,9 +10,11 @@ import {
 } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
 import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { orchestratePrismaComponents } from "./orchestratePrismaComponent";
 import { orchestratePrismaCorrect } from "./orchestratePrismaCorrect";
 import { orchestratePrismaReview } from "./orchestratePrismaReview";
@@ -22,7 +24,17 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: IAutoBeApplicationProps,
 ): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
+  // PREDICATION
   const start: Date = new Date();
+  const predicate: string | null = predicateStateMessage(ctx.state(), "prisma");
+  if (predicate !== null)
+    return ctx.assistantMessage({
+      type: "assistantMessage",
+      id: v4(),
+      created_at: start.toISOString(),
+      text: predicate,
+      completed_at: new Date().toISOString(),
+    });
   ctx.dispatch({
     type: "prismaStart",
     created_at: start.toISOString(),
@@ -31,12 +43,9 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   });
 
   // COMPONENTS
-  const componentEvent:
-    | AutoBeAssistantMessageHistory
-    | AutoBePrismaComponentsEvent = await orchestratePrismaComponents(ctx);
-  if (componentEvent.type === "assistantMessage")
-    return ctx.assistantMessage(componentEvent);
-  else ctx.dispatch(componentEvent);
+  const componentEvent: AutoBePrismaComponentsEvent =
+    await orchestratePrismaComponents(ctx);
+  ctx.dispatch(componentEvent);
 
   // CONSTRUCT AST DATA
   const schemaEvents: AutoBePrismaSchemasEvent[] =

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -1,13 +1,8 @@
-import {
-  AgenticaAssistantMessageHistory,
-  IAgenticaController,
-} from "@agentica/core";
-import { AutoBeAssistantMessageHistory } from "@autobe/interface";
+import { IAgenticaController } from "@agentica/core";
 import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
-import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
@@ -18,14 +13,14 @@ export async function orchestratePrismaComponents<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  message: string = "Please extract files and tables from the given documents.",
-): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent> {
+  message: string = "Design database from the given requirement analysis documents.",
+): Promise<AutoBePrismaComponentsEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBePrismaComponentApplication.IProps | null> = {
     value: null,
   };
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
-  const { histories, tokenUsage } = await ctx.conversate({
+  const { tokenUsage } = await ctx.conversate({
     source: "prismaComponents",
     histories: transformPrismaComponentsHistories(ctx.state(), prefix),
     controller: createController({
@@ -34,19 +29,11 @@ export async function orchestratePrismaComponents<
         pointer.value = next;
       },
     }),
-    enforceFunctionCall: false,
+    enforceFunctionCall: true,
     message,
   });
-  if (histories.at(-1)?.type === "assistantMessage")
-    return {
-      ...(histories.at(-1)! as AgenticaAssistantMessageHistory),
-      created_at: start.toISOString(),
-      completed_at: new Date().toISOString(),
-      id: v4(),
-    } satisfies AutoBeAssistantMessageHistory;
-  else if (pointer.value === null) {
+  if (pointer.value === null)
     throw new Error("Failed to extract files and tables."); // unreachable
-  }
   return {
     type: "prismaComponents",
     created_at: start.toISOString(),

package/src/orchestrate/prisma/orchestratePrismaReview.ts

@@ -1,5 +1,5 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBePrisma } from "@autobe/interface";
+import { AutoBePrisma, AutoBeProgressEventBase } from "@autobe/interface";
 import { AutoBePrismaReviewEvent } from "@autobe/interface/src/events/AutoBePrismaReviewEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
@@ -7,7 +7,6 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { IProgress } from "../internal/IProgress";
 import { transformPrismaReviewHistories } from "./histories/transformPrismaReviewHistories";
 import { IAutoBePrismaReviewApplication } from "./structures/IAutoBePrismaReviewApplication";
 
@@ -17,15 +16,22 @@ export async function orchestratePrismaReview<Model extends ILlmSchema.Model>(
   schemas: Record<string, string>,
   componentList: AutoBePrisma.IComponent[],
 ): Promise<AutoBePrismaReviewEvent[]> {
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     completed: 0,
     total: componentList.length,
   };
-  return await Promise.all(
-    componentList.map((component) =>
-      step(ctx, application, schemas, component, progress),
-    ),
-  );
+  return (
+    await Promise.all(
+      componentList.map(async (component) => {
+        try {
+          return await step(ctx, application, schemas, component, progress);
+        } catch {
+          ++progress.completed;
+          return null;
+        }
+      }),
+    )
+  ).filter((v) => v !== null);
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -33,7 +39,7 @@ async function step<Model extends ILlmSchema.Model>(
   application: AutoBePrisma.IApplication,
   schemas: Record<string, string>,
   component: AutoBePrisma.IComponent,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
 ): Promise<AutoBePrismaReviewEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBePrismaReviewApplication.IProps | null> = {

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

@@ -33,7 +33,7 @@ export const transformRealizeAuthorizationHistories = <
         "",
         "## Prisma Schema",
         "",
-        JSON.stringify(ctx.state().prisma?.schemas, null, 2),
+        JSON.stringify(ctx.state().prisma?.schemas),
         "",
         "## Component Naming Convention",
         "",

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

@@ -40,33 +40,29 @@ export const transformRealizeAuthorizationCorrectHistories = <
         "## Generated TypeScript Code",
         "",
         "```json",
-        `${JSON.stringify(
-          {
-            provider: {
-              location: auth.provider.location,
-              name: auth.provider.name,
-              content: auth.provider.content,
-            },
-            decorator: {
-              location: auth.decorator.location,
-              name: auth.decorator.name,
-              content: auth.decorator.content,
-            },
-            payload: {
-              location: auth.payload.location,
-              name: auth.payload.name,
-              content: auth.payload.content,
-            },
-          } satisfies Omit<AutoBeRealizeAuthorization, "role">,
-          null,
-          2,
-        )}`,
+        `${JSON.stringify({
+          provider: {
+            location: auth.provider.location,
+            name: auth.provider.name,
+            content: auth.provider.content,
+          },
+          decorator: {
+            location: auth.decorator.location,
+            name: auth.decorator.name,
+            content: auth.decorator.content,
+          },
+          payload: {
+            location: auth.payload.location,
+            name: auth.payload.name,
+            content: auth.payload.content,
+          },
+        } satisfies Omit<AutoBeRealizeAuthorization, "role">)}`,
         "```",
         "",
         "## Prisma Schema",
         "",
         "```json",
-        `${JSON.stringify(ctx.state().prisma?.schemas, null, 2)}`,
+        `${JSON.stringify(ctx.state().prisma?.schemas)}`,
         "```",
         "",
         "## File Paths",
@@ -80,7 +76,7 @@ export const transformRealizeAuthorizationCorrectHistories = <
         "Fix the compilation error in the provided code.",
         "",
         "```json",
-        JSON.stringify(diagnostics, null, 2),
+        JSON.stringify(diagnostics),
         "```",
         "## Component Naming Convention",
         "",