@autobe/agent 0.20.0 → 0.22.0

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.d.ts

@@ -25,6 +25,8 @@ export interface IAutoBeAnalyzeReviewApplication {
 export declare namespace IAutoBeAnalyzeReviewApplication {
     interface IProps {
         /**
+         * Step 1 (CoT: Review Phase) - Enhancement Criteria
+         *
          * The enhancement criteria and guidelines that the agent must follow.
          *
          * This includes:
@@ -50,6 +52,8 @@ export declare namespace IAutoBeAnalyzeReviewApplication {
          */
         review: string;
         /**
+         * Step 2 (CoT: Plan Phase) - Original Document Plan
+         *
          * The document plan that was used to create the content.
          *
          * This helps the reviewer understand:
@@ -64,6 +68,8 @@ export declare namespace IAutoBeAnalyzeReviewApplication {
          */
         plan: string;
         /**
+         * Step 3 (CoT: Content Phase) - Complete Document Content
+         *
          * The actual markdown document content that incorporates review feedback.
          *
          * This field contains a COMPLETE MARKDOWN DOCUMENT that has already

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.d.ts

@@ -15,6 +15,8 @@ export interface IAutoBeAnalyzeWriteApplication {
 export declare namespace IAutoBeAnalyzeWriteApplication {
     interface IProps {
         /**
+         * Step 1 (CoT: Plan Phase) - Document Planning Structure
+         *
          * The document planning structure that outlines what needs to be written.
          *
          * This includes:
@@ -39,6 +41,8 @@ export declare namespace IAutoBeAnalyzeWriteApplication {
          */
         plan: string;
         /**
+         * Step 2 (CoT: Write Phase) - Document Content Creation
+         *
          * The initial content or context for the document being written.
          *
          * This may include:

package/lib/orchestrate/interface/histories/transformInterfaceEndpointsReviewHistories.d.ts

@@ -0,0 +1,4 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+export declare const transformInterfaceEndpointsReviewHistories: (state: AutoBeState, endpoints: AutoBeOpenApi.IEndpoint[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/interface/histories/transformInterfaceSchemasReviewHistories.d.ts

@@ -1,4 +1,4 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
 import { AutoBeState } from "../../../context/AutoBeState";
-export declare const transformInterfaceSchemasReviewHistories: (state: AutoBeState, operations: AutoBeOpenApi.IOperation[], schemaDescriptive: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;
+export declare const transformInterfaceSchemasReviewHistories: (state: AutoBeState, operations: AutoBeOpenApi.IOperation[], schemaDescriptive: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/interface/orchestrateInterfaceComplement.d.ts

@@ -1,4 +1,4 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, document: AutoBeOpenApi.IDocument, life?: number): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>>;
+export declare function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, document: AutoBeOpenApi.IDocument): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>>;

package/lib/orchestrate/interface/orchestrateInterfaceEndpointsReview.d.ts

@@ -0,0 +1,10 @@
+import { IAgenticaController } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeInterfaceEndpointsReviewApplication } from "./structures/IAutoBeInterfaceEndpointsReviewApplication";
+export declare function orchestrateInterfaceEndpointsReview<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, endpoints: AutoBeOpenApi.IEndpoint[], message?: string): Promise<AutoBeOpenApi.IEndpoint[]>;
+export declare function createController<Model extends ILlmSchema.Model>(props: {
+    model: Model;
+    build: (props: IAutoBeInterfaceEndpointsReviewApplication.IProps) => void;
+}): IAgenticaController.IClass<Model>;

package/lib/orchestrate/interface/orchestrateInterfaceSchemasReview.d.ts

@@ -1,4 +1,9 @@
 import { AutoBeOpenApi, AutoBeProgressEventBase } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateInterfaceSchemasReview<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>, progress: AutoBeProgressEventBase): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>>;
+export declare function orchestrateInterfaceSchemasReview<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>>;
+export declare function step<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>, progress: AutoBeProgressEventBase, promptCacheKey: string): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>>;
+export interface IProgress {
+    total: number;
+    completed: number;
+}

package/lib/orchestrate/interface/structures/IAutoBeInterfaceEndpointsReviewApplication.d.ts

@@ -0,0 +1,60 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+/**
+ * Interface for reviewing and refining API endpoints through holistic analysis.
+ *
+ * This application performs comprehensive review of all endpoints generated
+ * through divide-and-conquer strategy, ensuring consistency, eliminating
+ * redundancy, and preventing over-engineering across the entire API surface.
+ */
+export interface IAutoBeInterfaceEndpointsReviewApplication {
+    /**
+     * Reviews and refines the complete collection of API endpoints.
+     *
+     * This method consolidates all endpoints generated independently by different
+     * groups and performs holistic review to:
+     * - Ensure naming consistency across all endpoints
+     * - Remove duplicate or overlapping endpoints
+     * - Eliminate over-engineered solutions
+     * - Standardize path structures and HTTP methods
+     * - Verify REST API design principles
+     *
+     * The review process examines the entire API as a cohesive system rather
+     * than individual endpoints, ensuring the final API is intuitive, maintainable,
+     * and follows best practices.
+     *
+     * @param next - The review results and refined endpoint collection
+     */
+    reviewEndpoints(next: IAutoBeInterfaceEndpointsReviewApplication.IProps): void;
+}
+export declare namespace IAutoBeInterfaceEndpointsReviewApplication {
+    interface IProps {
+        /**
+         * 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[];
+    }
+}

package/lib/orchestrate/interface/structures/IAutoBeInterfaceOperationApplication.d.ts

@@ -85,44 +85,6 @@ export declare namespace IAutoBeInterfaceOperationApplication {
      * ```
      */
     interface IOperation extends Omit<AutoBeOpenApi.IOperation, "authorizationRole" | "authorizationType"> {
-        /**
-         * Prisma schema models relevant to this operation.
-         *
-         * Contains the complete Prisma schema definitions for all entities involved
-         * in this operation, including their fields, relations, and database
-         * constraints. This enables comprehensive validation and schema-aware
-         * operation design.
-         *
-         * The schema information serves multiple critical purposes:
-         *
-         * - **Field Verification**: Ensures all referenced fields actually exist in
-         *   the database schema and have the correct types
-         * - **Relationship Validation**: Confirms that entity relationships are
-         *   properly defined and can support the operation's data access patterns
-         * - **Soft-Delete Detection**: For DELETE operations, identifies whether
-         *   entities have soft-delete fields (deleted_at, is_deleted, etc.) to
-         *   determine if the operation should perform logical deletion instead of
-         *   physical removal
-         * - **Constraint Awareness**: Understands unique constraints, required
-         *   fields, and default values to generate accurate request/response
-         *   schemas
-         *
-         * Example content might include:
-         *
-         * ```prisma
-         * model User {
-         *   id         String    @id @default(uuid())
-         *   email      String    @unique
-         *   name       String
-         *   deleted_at DateTime? // Indicates soft-delete capability
-         *   posts      Post[]
-         * }
-         * ```
-         *
-         * This schema context ensures operations are fully aligned with the actual
-         * database structure and business logic requirements.
-         */
-        prisma_schemas: string;
         /**
          * Authorization roles required to access this API operation.
          *

package/lib/orchestrate/interface/structures/IAutoBeInterfaceOperationsReviewApplication.d.ts

@@ -4,19 +4,21 @@ import { AutoBeOpenApi } from "@autobe/interface";
  *
  * Provides functionality to systematically review generated API operations
  * against business requirements, technical specifications, and OpenAPI
- * standards. The review process ensures each operation meets quality criteria
- * before proceeding to implementation.
+ * standards. The review process outputs a structured thinking process with
+ * analytical findings and actionable improvements, along with the final
+ * enhanced operations ready for implementation.
  */
 export interface IAutoBeInterfaceOperationsReviewApplication {
     /**
      * Reviews a batch of API operations for quality and correctness.
      *
-     * Validates each operation's request/response schemas, authentication
-     * handling, error responses, and documentation completeness. Operations are
-     * marked as passed or failed based on compliance with enterprise standards.
+     * Analyzes operations for security vulnerabilities, schema compliance,
+     * logical consistency, and standard adherence. Outputs a structured thinking
+     * process containing review findings and improvement plans, plus the final
+     * production-ready operations with all critical issues resolved.
      *
-     * @param input Collection of operations to review with their validation
-     *   results
+     * @param input Properties containing the thinking process (review & plan)
+     *   and the enhanced operations content
      */
     reviewOperations(input: IAutoBeInterfaceOperationsReviewApplication.IProps): void;
 }
@@ -29,6 +31,45 @@ export declare namespace IAutoBeInterfaceOperationsReviewApplication {
      * of the AutoBeInterfaceOperationsReviewEvent.
      */
     interface IProps {
+        /**
+         * Comprehensive thinking process for API operation review.
+         *
+         * Encapsulates the agent's analytical review findings and actionable
+         * improvement plan. This structured thinking process ensures systematic
+         * evaluation of API operations against AutoBE's quality standards before
+         * generating the final enhanced operations.
+         */
+        think: IThink;
+        /**
+         * Production-ready operations with all critical issues resolved.
+         *
+         * Final API operations after systematic enhancement:
+         *
+         * - **Security Fixes Applied**: All authentication boundaries enforced,
+         *   sensitive data removed from responses, proper authorization
+         *   implemented
+         * - **Logic Corrections Made**: Return types match operation intent, HTTP
+         *   methods align with semantics, parameters properly utilized
+         * - **Schema Alignment Verified**: All fields exist in Prisma schema, types
+         *   correctly mapped, relationships properly defined
+         * - **Quality Improvements Added**: Enhanced documentation, format
+         *   specifications, validation rules, consistent naming patterns
+         *
+         * If no issues were found during review, this contains the exact original
+         * operations unchanged. These operations are validated and ready for schema
+         * generation and subsequent implementation phases.
+         */
+        content: AutoBeOpenApi.IOperation[];
+    }
+    /**
+     * 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.
+     */
+    interface IThink {
         /**
          * Comprehensive review analysis with prioritized findings.
          *
@@ -72,99 +113,5 @@ export declare namespace IAutoBeInterfaceOperationsReviewApplication {
          * needed, and the rationale for the modification.
          */
         plan: string;
-        /**
-         * Production-ready operations with all critical issues resolved.
-         *
-         * Final API operations after systematic enhancement:
-         *
-         * - **Security Fixes Applied**: All authentication boundaries enforced,
-         *   sensitive data removed from responses, proper authorization
-         *   implemented
-         * - **Logic Corrections Made**: Return types match operation intent, HTTP
-         *   methods align with semantics, parameters properly utilized
-         * - **Schema Alignment Verified**: All fields exist in Prisma schema, types
-         *   correctly mapped, relationships properly defined
-         * - **Quality Improvements Added**: Enhanced documentation, format
-         *   specifications, validation rules, consistent naming patterns
-         *
-         * If no issues were found during review, this contains the exact original
-         * operations unchanged. These operations are validated and ready for schema
-         * generation and subsequent implementation phases.
-         */
-        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": {...}
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    interface IOperation extends Omit<AutoBeOpenApi.IOperation, "authorizationType"> {
-        /**
-         * Prisma schema models relevant to this operation.
-         *
-         * Contains the complete Prisma schema definitions for all entities involved
-         * in this operation, including their fields, relations, and database
-         * constraints. This enables comprehensive validation and schema-aware
-         * operation design.
-         *
-         * The schema information serves multiple critical purposes:
-         *
-         * - **Field Verification**: Ensures all referenced fields actually exist in
-         *   the database schema and have the correct types
-         * - **Relationship Validation**: Confirms that entity relationships are
-         *   properly defined and can support the operation's data access patterns
-         * - **Soft-Delete Detection**: For DELETE operations, identifies whether
-         *   entities have soft-delete fields (deleted_at, is_deleted, etc.) to
-         *   determine if the operation should perform logical deletion instead of
-         *   physical removal
-         * - **Constraint Awareness**: Understands unique constraints, required
-         *   fields, and default values to generate accurate request/response
-         *   schemas
-         *
-         * Example content might include:
-         *
-         * ```prisma
-         * model User {
-         *   id         String    @id @default(uuid())
-         *   email      String    @unique
-         *   name       String
-         *   deleted_at DateTime? // Indicates soft-delete capability
-         *   posts      Post[]
-         * }
-         * ```
-         *
-         * This schema context ensures operations are fully aligned with the actual
-         * database structure and business logic requirements.
-         */
-        prisma_schemas: string;
     }
 }

package/lib/orchestrate/interface/structures/IAutobeInterfaceSchemasReviewApplication.d.ts

@@ -27,15 +27,42 @@ export declare namespace IAutoBeInterfaceSchemasReviewApplication {
      * interface to understand what outputs are required.
      */
     interface IProps {
+        think: IThink;
+        /**
+         * Final validated and enhanced schemas ready for production use.
+         *
+         * 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
+         *
+         * 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
+         * the system, so it must always contain complete, valid schemas.
+         */
+        content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    }
+    interface IThink {
         /**
          * Issues and problems found during schema analysis.
          *
-         * DO: Document only problems that need fixing.
-         * DO NOT: Include positive feedback, compliments, or confirmations
+         * DO: Document only problems that need fixing. DO NOT: Include positive
+         * feedback, compliments, or confirmations
          *
          * Focus exclusively on issues organized by severity:
          *
          * Severity levels:
+         *
          * - Security vulnerabilities (exposed passwords, missing auth boundaries)
          * - Missing required variants, incorrect type mappings
          * - Missing format specifications, incomplete relationships
@@ -60,26 +87,5 @@ export declare namespace IAutoBeInterfaceSchemasReviewApplication {
          * field.
          */
         plan: string;
-        /**
-         * Final validated and enhanced schemas ready for production use.
-         *
-         * 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
-         *
-         * 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
-         * the system, so it must always contain complete, valid schemas.
-         */
-        content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>;
     }
 }

package/lib/orchestrate/interface/utils/JsonSchemaFactory.d.ts

@@ -0,0 +1,9 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export declare namespace JsonSchemaFactory {
+    const presets: (typeNames: Set<string>) => Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    const authorize: (schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>) => void;
+    const page: (key: string) => AutoBeOpenApi.IJsonSchemaDescriptive.IObject;
+    const fix: (path: string, input: unknown) => void;
+    const isPage: (key: string) => boolean;
+    const getPageName: (key: string) => string;
+}

package/lib/orchestrate/interface/utils/JsonSchemaNamingConvention.d.ts

@@ -0,0 +1,5 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export declare namespace JsonSchemaNamingConvention {
+    const operations: (operations: AutoBeOpenApi.IOperation[]) => void;
+    const schemas: (operations: AutoBeOpenApi.IOperation[], ...componentSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[]) => void;
+}

package/lib/orchestrate/interface/utils/fulfillJsonSchemaErrorMessages.d.ts

@@ -0,0 +1,2 @@
+import { IValidation } from "typia";
+export declare const fulfillJsonSchemaErrorMessages: (errors: IValidation.IError[]) => void;

package/lib/orchestrate/prisma/orchestratePrismaCorrect.d.ts

@@ -1,4 +1,4 @@
 import { AutoBePrisma, IAutoBePrismaValidation } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, application: AutoBePrisma.IApplication, life?: number): Promise<IAutoBePrismaValidation>;
+export declare function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, application: AutoBePrisma.IApplication): Promise<IAutoBePrismaValidation>;

package/lib/orchestrate/realize/histories/transformRealizeCorrectHistories.d.ts

@@ -1,14 +1,14 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeRealizeAuthorization } from "@autobe/interface";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
-import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
 export declare function transformRealizeCorrectHistories(props: {
     state: AutoBeState;
-    scenario: IAutoBeRealizeScenarioApplication.IProps;
-    artifacts: IAutoBeTestScenarioArtifacts;
+    scenario: IAutoBeRealizeScenarioResult;
     authorization: AutoBeRealizeAuthorization | null;
     totalAuthorizations: AutoBeRealizeAuthorization[];
     code: string;
-    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+    dto: Record<string, string>;
+    failures: IAutoBeRealizeFunctionFailure[];
 }): Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeWriteHistories.d.ts

@@ -1,14 +1,11 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeRealizeAuthorization } from "@autobe/interface";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
-import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
-export declare const transformRealizeWriteHistories: (props: IProps) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;
-interface IProps {
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+export declare const transformRealizeWriteHistories: (props: {
     state: AutoBeState;
-    scenario: IAutoBeRealizeScenarioApplication.IProps;
-    artifacts: IAutoBeTestScenarioArtifacts;
+    scenario: IAutoBeRealizeScenarioResult;
     authorization: AutoBeRealizeAuthorization | null;
     totalAuthorizations: AutoBeRealizeAuthorization[];
-}
-export {};
+    dto: Record<string, string>;
+}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/internal/compileRealizeFiles.d.ts

@@ -1,7 +1,7 @@
-import { AutoBeRealizeAuthorization, AutoBeRealizeFunction, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeRealizeAuthorization, AutoBeRealizeFunction, AutoBeRealizeValidateEvent } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../../context/AutoBeContext";
 export declare function compileRealizeFiles<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
     authorizations: AutoBeRealizeAuthorization[];
     functions: AutoBeRealizeFunction[];
-}): Promise<IAutoBeTypeScriptCompileResult>;
+}): Promise<AutoBeRealizeValidateEvent>;

package/lib/orchestrate/realize/orchestrateRealizeCorrect.d.ts

@@ -1,12 +1,19 @@
-import { AutoBeProgressEventBase, AutoBeRealizeAuthorization, AutoBeRealizeCorrectEvent, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeProgressEventBase, AutoBeRealizeAuthorization, AutoBeRealizeCorrectEvent, AutoBeRealizeFunction, AutoBeRealizeValidateEvent } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
-export declare function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
+import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+export declare function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenarios: IAutoBeRealizeScenarioResult[], authorizations: AutoBeRealizeAuthorization[], functions: AutoBeRealizeFunction[], failures: IAutoBeRealizeFunctionFailure[], progress: IProgress, life?: number): Promise<AutoBeRealizeValidateEvent>;
+export declare function correct<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
     authorization: AutoBeRealizeAuthorization | null;
     totalAuthorizations: AutoBeRealizeAuthorization[];
-    scenario: IAutoBeRealizeScenarioApplication.IProps;
-    code: string;
-    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+    scenario: IAutoBeRealizeScenarioResult;
+    function: AutoBeRealizeFunction;
+    failures: IAutoBeRealizeFunctionFailure[];
     progress: AutoBeProgressEventBase;
 }): Promise<AutoBeRealizeCorrectEvent>;
+interface IProgress {
+    total: number;
+    completed: number;
+}
+export {};

package/lib/orchestrate/realize/orchestrateRealizeScenario.d.ts

@@ -1,7 +1,7 @@
 import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 /**
  * Generates a planning result that defines what kind of function should be
  * created, based solely on the provided Swagger (OpenAPI) operation — without
@@ -22,4 +22,4 @@ import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeSc
  * @returns A planning object containing all structural information needed to
  *   generate the function
  */
-export declare const orchestrateRealizeScenario: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operation: AutoBeOpenApi.IOperation, authorization?: AutoBeRealizeAuthorization) => IAutoBeRealizeScenarioApplication.IProps;
+export declare const orchestrateRealizeScenario: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operation: AutoBeOpenApi.IOperation, authorization?: AutoBeRealizeAuthorization) => IAutoBeRealizeScenarioResult;

package/lib/orchestrate/realize/orchestrateRealizeWrite.d.ts

@@ -1,11 +1,11 @@
 import { AutoBeProgressEventBase, AutoBeRealizeAuthorization, AutoBeRealizeWriteEvent } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 export declare function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
     totalAuthorizations: AutoBeRealizeAuthorization[];
     authorization: AutoBeRealizeAuthorization | null;
-    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    scenario: IAutoBeRealizeScenarioResult;
     progress: AutoBeProgressEventBase;
     promptCacheKey: string;
 }): Promise<AutoBeRealizeWriteEvent>;

package/lib/orchestrate/realize/structures/IAutoBeRealizeAuthorizationApplication.d.ts

@@ -1,5 +1,22 @@
 import { CamelPattern, PascalPattern } from "@autobe/interface";
 export interface IAutoBeRealizeAuthorizationApplication {
+    /**
+     * Generates authentication provider, decorator, and payload type for role-based authorization.
+     *
+     * This method creates a complete authentication infrastructure for a specific
+     * role in the NestJS application. It generates three interconnected components
+     * that work together to provide JWT-based authentication and authorization.
+     *
+     * The generated components include:
+     * - **Provider Function**: Handles JWT verification and user validation from database
+     * - **Decorator**: NestJS parameter decorator for injecting authenticated user data
+     * - **Payload Type**: TypeScript interface defining the authenticated user structure
+     *
+     * All components follow strict naming conventions and integrate with the existing
+     * authentication architecture using the shared jwtAuthorize function.
+     *
+     * @param next Properties containing provider, decorator, and payload type configurations
+     */
     createDecorator: (next: IAutoBeRealizeAuthorizationApplication.IProps) => void;
 }
 export declare namespace IAutoBeRealizeAuthorizationApplication {

package/lib/orchestrate/realize/structures/IAutoBeRealizeAuthorizationCorrectApplication.d.ts

@@ -1,5 +1,25 @@
 import { IAutoBeRealizeAuthorizationApplication } from "./IAutoBeRealizeAuthorizationApplication";
 export interface IAutoBeRealizeAuthorizationCorrectApplication {
+    /**
+     * Corrects TypeScript compilation errors in authentication components.
+     *
+     * This method analyzes and fixes compilation errors in previously generated
+     * authentication provider, decorator, and payload type implementations. It
+     * performs systematic error diagnosis and generates corrected versions of
+     * all three components while maintaining their interconnected functionality.
+     *
+     * The correction process includes:
+     * - TypeScript error analysis and categorization by component
+     * - Identification of type mismatches, import issues, and syntax errors
+     * - Clear solution guidance for each identified problem
+     * - Regeneration of all components with fixes applied
+     *
+     * The corrected components maintain the same naming conventions and
+     * architectural patterns as the original generation while resolving all
+     * compilation issues.
+     *
+     * @param next Properties containing error analysis, solution guidance, and corrected components
+     */
     correctDecorator: (next: IAutoBeRealizeAuthorizationCorrectApplication.IProps) => void;
 }
 export declare namespace IAutoBeRealizeAuthorizationCorrectApplication {