@autobe/agent 0.16.1 → 0.18.0

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

@@ -0,0 +1,96 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+/**
+ * Application interface for reviewing and validating API operations.
+ *
+ * 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.
+ */
+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.
+     *
+     * @param input Collection of operations to review with their validation
+     *   results
+     */
+    reviewOperations(input: IAutoBeInterfaceOperationsReviewApplication.IProps): void;
+}
+export declare namespace IAutoBeInterfaceOperationsReviewApplication {
+    /**
+     * Properties for API operation review and improvement process.
+     *
+     * 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.
+     */
+    interface IProps {
+        /**
+         * Comprehensive review analysis with prioritized findings.
+         *
+         * Systematic assessment organized by severity levels (CRITICAL, HIGH,
+         * MEDIUM, LOW):
+         *
+         * - **Security Analysis**: Authentication boundary violations, exposed
+         *   passwords/tokens, unauthorized data access patterns, SQL injection
+         *   risks
+         * - **Logic Validation**: Return type consistency (list operations returning
+         *   arrays, single retrieval returning single items), HTTP method semantics
+         *   alignment, parameter usage verification
+         * - **Schema Compliance**: Field existence in Prisma schema, type accuracy,
+         *   relationship validity, required field handling
+         * - **Quality Assessment**: Documentation completeness, naming conventions,
+         *   error handling patterns, pagination standards
+         *
+         * Each finding includes specific examples, current vs expected behavior,
+         * and concrete fix recommendations. Critical security issues and logical
+         * contradictions are highlighted for immediate attention.
+         */
+        review: string;
+        /**
+         * Prioritized action plan for identified issues.
+         *
+         * Structured improvement strategy categorized by severity:
+         *
+         * - **Immediate Actions (CRITICAL)**: Security vulnerabilities that must be
+         *   fixed before production (password exposure, missing authorization,
+         *   authentication bypass risks)
+         * - **Required Fixes (HIGH)**: Functional issues affecting API correctness
+         *   (wrong return types, missing required fields, schema mismatches)
+         * - **Recommended Improvements (MEDIUM)**: Quality enhancements for better
+         *   API design (validation rules, format specifications, consistency)
+         * - **Optional Enhancements (LOW)**: Documentation and usability improvements
+         *
+         * If all operations pass review without issues, contains: "No improvements
+         * required. All operations meet AutoBE standards."
+         *
+         * Each action item includes the specific operation path, the exact change
+         * 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: AutoBeOpenApi.IOperation[];
+    }
+}

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

@@ -0,0 +1,91 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export interface IAutoBeInterfaceSchemasReviewApplication {
+    /**
+     * Analyzes and improves OpenAPI schema definitions.
+     *
+     * This function receives schema definitions and performs comprehensive review
+     * and enhancement. It identifies issues, creates an improvement plan, and
+     * produces refined schemas that meet quality standards.
+     *
+     * The function populates three key outputs:
+     *
+     * - A detailed review of findings organized by severity
+     * - An actionable plan for improvements
+     * - Enhanced schemas with all issues resolved
+     *
+     * @param props Contains review findings, improvement plan, and enhanced
+     *   schemas
+     */
+    review: (props: IAutoBeInterfaceSchemasReviewApplication.IProps) => void;
+}
+export declare namespace IAutoBeInterfaceSchemasReviewApplication {
+    /**
+     * Schema review and enhancement parameters for the review function.
+     *
+     * When the review function is called, these properties must be populated to
+     * complete the schema validation and improvement process. The LLM uses this
+     * interface to understand what outputs are required.
+     */
+    interface IProps {
+        /**
+         * 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
+         *
+         * 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
+         *
+         * 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."
+         */
+        review: string;
+        /**
+         * Action plan for addressing identified issues.
+         *
+         * Must specify concrete fixes categorized by priority:
+         *
+         * - For perfect schemas: "No improvements required. All schemas meet AutoBE
+         *   standards."
+         * - For fixable issues: List each fix with operation path and exact change
+         * - For critical problems: Describe how schemas were recreated or corrected
+         *
+         * Never leave this empty. Always provide a clear plan even if no changes
+         * are needed. The plan documents what was done to produce the content
+         * field.
+         */
+        plan: string;
+        /**
+         * 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:
+         *
+         * - Empty object {} will cause all schemas to be deleted
+         * - Returning undefined or null
+         * - Including explanations or excuses in schema descriptions
+         * - Leaving 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/internal/IProgress.d.ts

@@ -0,0 +1,4 @@
+export interface IProgress {
+    total: number;
+    completed: number;
+}

package/lib/orchestrate/prisma/histories/transformPrismaComponentsHistories.d.ts

@@ -0,0 +1,3 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeState } from "../../../context/AutoBeState";
+export declare const transformPrismaComponentsHistories: (state: AutoBeState, prefix?: string | null) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/prisma/histories/transformPrismaCorrectHistories.d.ts

@@ -0,0 +1,3 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBePrismaValidation } from "@autobe/interface";
+export declare const transformPrismaCorrectHistories: (result: IAutoBePrismaValidation.IFailure) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/prisma/histories/transformPrismaReviewHistories.d.ts

@@ -0,0 +1,8 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBePrisma } from "@autobe/interface";
+export declare const transformPrismaReviewHistories: (props: {
+    analysis: Record<string, string>;
+    application: AutoBePrisma.IApplication;
+    schemas: Record<string, string>;
+    component: AutoBePrisma.IComponent;
+}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/prisma/histories/transformPrismaSchemaHistories.d.ts

@@ -0,0 +1,3 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBePrisma } from "@autobe/interface";
+export declare const transformPrismaSchemaHistories: (requirementAnalysisReport: Record<string, string>, targetComponent: AutoBePrisma.IComponent, otherTables: string[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

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

@@ -2,4 +2,4 @@ import { AutoBeAssistantMessageHistory, AutoBePrismaHistory } from "@autobe/inte
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-export declare const orchestratePrisma: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory>;
+export declare const orchestratePrisma: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: IAutoBeApplicationProps) => Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory>;

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

@@ -2,4 +2,4 @@ import { AutoBeAssistantMessageHistory } from "@autobe/interface";
 import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestratePrismaComponents<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, content?: string): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent>;
+export declare function orchestratePrismaComponents<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, message?: string): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent>;

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

@@ -0,0 +1,5 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { AutoBePrismaReviewEvent } from "@autobe/interface/src/events/AutoBePrismaReviewEvent";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestratePrismaReview<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, application: AutoBePrisma.IApplication, schemas: Record<string, string>, componentList: AutoBePrisma.IComponent[]): Promise<AutoBePrismaReviewEvent[]>;

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

@@ -2,4 +2,4 @@ import { AutoBePrisma } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, components: AutoBePrisma.IComponent[]): Promise<AutoBePrismaSchemasEvent[]>;
+export declare function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, componentList: AutoBePrisma.IComponent[]): Promise<AutoBePrismaSchemasEvent[]>;

package/lib/orchestrate/prisma/structures/IAutoBePrismaComponentApplication.d.ts

@@ -0,0 +1,121 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
+export interface IAutoBePrismaComponentApplication {
+    /**
+     * Organizes database tables into domain-based components for Prisma schema
+     * generation.
+     *
+     * Takes business requirements and groups related tables into logical domains,
+     * with each component becoming a separate .prisma file.
+     */
+    extractComponents(props: IAutoBePrismaComponentApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaComponentApplication {
+    interface IProps {
+        /**
+         * Initial thoughts on namespace classification criteria.
+         *
+         * Contains the AI agent's initial analysis and reasoning about how to
+         * organize tables into different business domains/namespaces.
+         *
+         * **Example:**
+         *
+         *     "Based on the business requirements, I identify several key domains:
+         *     - User-related entities should be grouped under 'Actors' namespace
+         *     - Product and sales information under 'Sales' namespace
+         *     - System configuration under 'Systematic' namespace"
+         */
+        thinking: string;
+        /**
+         * Review and refinement of the namespace classification.
+         *
+         * Contains the AI agent's review process, considering relationships between
+         * tables and potential improvements to the initial classification.
+         *
+         * **Example:**
+         *
+         *     "Upon review, I noticed that 'shopping_channel_categories' has strong
+         *     relationships with both channels and sales. However, since it primarily
+         *     defines the channel structure, it should remain in 'Systematic' namespace."
+         */
+        review: string;
+        /**
+         * Final decision on namespace classification.
+         *
+         * Contains the AI agent's final reasoning and rationale for the chosen
+         * namespace organization, explaining why this structure best serves the
+         * business requirements.
+         *
+         * **Example:**
+         *
+         *     "Final decision: Organize tables into 3 main namespaces:
+         *     1. Systematic - for channel and system configuration
+         *     2. Actors - for all user types (customers, citizens, administrators)
+         *     3. Sales - for product sales and related transactional data
+         *     This structure provides clear separation of concerns and follows DDD principles."
+         */
+        decision: string;
+        /**
+         * Array of domain components that group related database tables.
+         *
+         * Each component represents a business domain and becomes one Prisma schema
+         * file. Common domains include: Actors (users), Sales (products), Orders,
+         * Carts, etc.
+         *
+         * **Example:**
+         *
+         * ```typescript
+         * {
+         *   "components": [
+         *     {
+         *       "filename": "schema-02-systematic.prisma",
+         *       "namespace": "Systematic",
+         *       "thinking": "These tables all relate to system configuration and channel management. They form the foundation of the platform.",
+         *       "review": "Considering the relationships, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.",
+         *       "rationale": "Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.",
+         *       "tables": [
+         *         "shopping_channels",
+         *         "shopping_sections",
+         *         "shopping_channel_categories"
+         *       ]
+         *     },
+         *     {
+         *       "filename": "schema-03-actors.prisma",
+         *       "namespace": "Actors",
+         *       "thinking": "All user-related entities should be grouped together as they share authentication and identity patterns.",
+         *       "review": "While customers interact with sales, the customer entity itself is about identity, not transactions.",
+         *       "rationale": "This component groups all actor-related tables to maintain separation between identity management and business transactions.",
+         *       "tables": [
+         *         "shopping_customers",
+         *         "shopping_citizens",
+         *         "shopping_administrators"
+         *       ]
+         *     },
+         *     {
+         *       "filename": "schema-04-sales.prisma",
+         *       "namespace": "Sales",
+         *       "thinking": "Product catalog and sales-related tables belong together as they form the core commerce functionality.",
+         *       "review": "Sales snapshots are integral to the sales domain for tracking product history and price changes.",
+         *       "rationale": "Consolidating all sales-related tables enables coherent management of the entire product lifecycle.",
+         *       "tables": [
+         *         "shopping_sales",
+         *         "shopping_sale_snapshots",
+         *         "shopping_sale_units",
+         *         "shopping_sale_unit_options"
+         *       ]
+         *     }
+         *   ]
+         * }
+         * ```
+         *
+         * **Notes:**
+         *
+         * - Table names must follow snake_case convention with domain prefix (e.g.,
+         *   `shopping_customers`)
+         * - Each component becomes one `.prisma` file containing related models
+         * - Filename numbering indicates dependency order for schema generation
+         * - Namespace is used for documentation organization and domain grouping
+         */
+        components: AutoBePrisma.IComponent[] & tags.MinItems<1>;
+    }
+}

package/lib/orchestrate/prisma/structures/IAutoBePrismaCorrectApplication.d.ts

@@ -0,0 +1,142 @@
+import { AutoBePrisma } from "@autobe/interface";
+export interface IAutoBePrismaCorrectApplication {
+    /**
+     * Fixes validation errors in specific AutoBePrisma models while preserving
+     * ALL existing business logic and model descriptions.
+     *
+     * ## Core Rules
+     *
+     * 1. Fix ONLY validation errors in provided models - never remove business
+     *    descriptions
+     * 2. Apply minimal changes to error models only - preserve original design
+     *    intent
+     * 3. Return ONLY corrected models - unchanged models remain in original schema
+     * 4. Maintain referential integrity with unchanged models
+     *
+     * ## Targeted Scope
+     *
+     * - Process ONLY models with validation errors from IError[] array
+     * - Exclude models without errors from processing and output
+     * - Minimize context usage by returning corrected models only
+     * - Preserve unchanged models in their original state
+     *
+     * ## Fix Strategy
+     *
+     * - Resolve validation errors within specific models only
+     * - Fix field duplications, invalid references, and type mismatches
+     * - Update cross-model references without modifying target models
+     * - Ensure naming conventions and index rules compliance in corrected models
+     */
+    correctPrismaSchemaFiles(props: IAutoBePrismaCorrectApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaCorrectApplication {
+    interface IProps {
+        /**
+         * Detailed execution plan for fixing `AutoBePrisma` validation errors in
+         * specific models.
+         *
+         * 🎯 Purpose: Enable systematic reasoning and step-by-step error resolution
+         * approach for targeted model validation issues
+         *
+         * 📋 Required Planning Content:
+         *
+         * 1. **Error Scope Analysis**
+         *
+         *    - List all validation errors from IAutoBePrismaValidation.IError[] array
+         *    - Extract unique table names from errors to identify affected models
+         *    - Categorize errors by type (field duplications, references, types,
+         *         indexes)
+         *    - Identify which models need correction vs. which remain unchanged
+         * 2. **Targeted Fix Strategy**
+         *
+         *    - Focus ONLY on models mentioned in validation errors
+         *    - Outline minimal changes needed for each affected model
+         *    - Plan cross-model reference updates (if any) without modifying non-error
+         *         models
+         *    - Ensure unchanged models maintain valid references to corrected models
+         * 3. **Model-Specific Fix Plan**
+         *
+         *    - Model-by-model modification plan for ONLY affected models
+         *    - Exact field additions, renames, or type corrections required
+         *    - Reference updates within corrected models only
+         *    - Index corrections limited to affected models
+         * 4. **Minimal Scope Validation**
+         *
+         *    - Confirm which models will be included in output (error models only)
+         *    - List models that will remain unchanged in original schema
+         *    - Identify cross-model dependencies without including unchanged models
+         *    - Preserve all business logic within corrected models
+         * 5. **Targeted Impact Assessment**
+         *
+         *    - Potential effects of fixes on unchanged models (reference validation)
+         *    - Verification points for corrected models only
+         *    - Ensure no new validation errors in targeted models
+         *    - Confirm minimal output scope compliance
+         *
+         * 💡 Example Planning Structure:
+         *
+         *     ## Error Scope
+         *     - Target Models: shopping_customers, shopping_orders (2 models only)
+         *     - Unchanged Models: All others remain in original schema
+         *
+         *     ## Targeted Fixes
+         *     - shopping_customers: Remove duplicate 'email' field
+         *     - shopping_orders: Update targetModel reference to 'shopping_customers'
+         *
+         *     ## Output Scope
+         *     - Return: Only shopping_customers and shopping_orders models
+         *     - Preserve: All other models unchanged in original schema
+         *
+         *     ## Cross-Model Impact
+         *     - Verify: shopping_orders still references shopping_customers correctly
+         *     - No changes needed in other models referencing these
+         */
+        planning: string;
+        /**
+         * ONLY the specific models that contain validation errors and need
+         * correction.
+         *
+         * 📥 Input Structure:
+         *
+         * - Contains ONLY models mentioned in IAutoBePrismaValidation.IError[] array
+         * - Each model has specific validation errors that need targeted correction
+         * - Models not mentioned in errors are excluded from this input
+         * - Represents minimal scope for error correction
+         *
+         * 🔍 Expected Validation Issues (Model-Specific):
+         *
+         * - Duplicate field/relation names within these specific models
+         * - Invalid foreign key references from these models to other models
+         * - Single foreign key fields in index arrays within these models
+         * - Invalid naming conventions within these specific models
+         * - Type validation errors in fields of these models
+         *
+         * 📝 Model Content Analysis (Targeted Scope):
+         *
+         * - Complete field definitions for each error model only
+         * - Relationships from these models (may reference unchanged models)
+         * - Indexes within these models that need correction
+         * - Business descriptions specific to these models
+         * - Cross-model references that need validation (read-only for targets)
+         *
+         * ⚠️ Processing Notes (Focused Approach):
+         *
+         * - Input contains ONLY models with validation errors
+         * - May reference other models not included in this input
+         * - Cross-model references must be validated but target models won't be
+         *   modified
+         * - Output should return corrected versions of ONLY these input models
+         * - All business logic and descriptions within these models must be preserved
+         * - Corrections must not break references from unchanged models
+         *
+         * 🎯 Correction Scope:
+         *
+         * - Fix validation errors within these specific models
+         * - Update internal model structure (fields, relations, indexes)
+         * - Correct references to external models (without modifying targets)
+         * - Maintain compatibility with unchanged models in the full schema
+         * - Return corrected versions of ONLY these models
+         */
+        models: AutoBePrisma.IModel[];
+    }
+}

package/lib/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.d.ts

@@ -0,0 +1,105 @@
+import { AutoBePrisma } from "@autobe/interface";
+export interface IAutoBePrismaReviewApplication {
+    /**
+     * Reviews and validates Prisma schema modifications to ensure compliance with
+     * database design best practices and business requirements.
+     *
+     * Performs comprehensive validation of proposed schema changes including
+     * normalization compliance, relationship integrity, performance optimization,
+     * and business logic alignment. The review process ensures all modifications
+     * maintain data consistency and follow enterprise-level database standards.
+     */
+    reviewSchemaFile(props: IAutoBePrismaReviewApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaReviewApplication {
+    interface IProps {
+        /**
+         * Comprehensive review analysis of the proposed schema modifications.
+         *
+         * Contains the AI agent's detailed evaluation of the schema changes,
+         * including validation of normalization compliance, relationship integrity,
+         * index optimization, and business requirement alignment. The review
+         * identifies potential issues and confirms adherence to best practices.
+         *
+         * **Review Dimensions:**
+         *
+         * - **Normalization Validation**: Confirms 3NF compliance and proper data
+         *   structure
+         * - **Relationship Integrity**: Validates foreign key references and
+         *   cardinality
+         * - **Performance Optimization**: Reviews indexing strategy and query
+         *   patterns
+         * - **Business Logic Alignment**: Ensures schema supports all use cases
+         * - **Naming Conventions**: Verifies consistent naming patterns
+         * - **Data Type Consistency**: Confirms appropriate field types
+         * - **Temporal Field Handling**: Validates audit trail implementation
+         *
+         * **Example:**
+         *
+         *     "After reviewing the schema modifications:
+         *     1. All tables properly implement UUID primary keys
+         *     2. Foreign key relationships correctly reference existing models
+         *     3. Composite indexes optimize for common query patterns
+         *     4. Snapshot tables include proper temporal fields
+         *     5. Materialized views (mv_) contain appropriate denormalization
+         *     The schema follows all best practices and is ready for implementation."
+         */
+        review: string;
+        /**
+         * Strategic database design plan that guided the schema creation.
+         *
+         * Contains the original planning document that outlines the database
+         * architecture strategy, including table structures, relationships,
+         * normalization approach, and business requirement mapping. This plan
+         * serves as the blueprint for validating the implemented schema.
+         *
+         * **Planning Components:**
+         *
+         * - **Business Requirements**: Mapping of business needs to database
+         *   structures
+         * - **Table Design**: Entity definitions and attribute specifications
+         * - **Relationship Strategy**: Cardinality and referential integrity planning
+         * - **Normalization Approach**: Application of 1NF, 2NF, 3NF principles
+         * - **Performance Considerations**: Index strategy and query optimization
+         * - **Snapshot Architecture**: Temporal data handling and audit requirements
+         * - **Materialized Views**: Denormalization strategy for performance
+         *
+         * **Example:**
+         *
+         *     "Database Design Strategy:
+         *     Component: Sales Domain
+         *     Tables: shopping_sales, shopping_sale_snapshots, shopping_sale_units
+         *
+         *     Design Approach:
+         *     - Normalize product catalog to 3NF for data integrity
+         *     - Implement snapshot pattern for price history tracking
+         *     - Create composite indexes for product search queries
+         *     - Use materialized views for sales analytics dashboards"
+         */
+        plan: string;
+        /**
+         * Array of Prisma models that have been modified based on review feedback.
+         *
+         * Contains ONLY the models that required changes, not the entire schema.
+         * Each model represents a complete table definition with all fields,
+         * relationships, indexes, and documentation. These modifications will be
+         * applied to the models to produce the final implementation.
+         *
+         * **Model Requirements:**
+         *
+         * - **Complete Models**: Each entry must be a complete model definition
+         * - **Targeted Changes**: Only includes models that need modifications
+         * - **AST Compliance**: Follows AutoBePrisma.IModel interface structure
+         * - **Relationship Integrity**: All foreign keys reference valid models
+         * - **Index Optimization**: Strategic indexes without redundancy
+         * - **Documentation**: Comprehensive English descriptions
+         *
+         * **Notes:**
+         *
+         * - Models not included in this array remain unchanged from the models
+         * - The final schema merges these modifications with the original models
+         * - All modifications must resolve issues identified in the review
+         */
+        modifications: AutoBePrisma.IModel[];
+    }
+}