Aggregated token usage and function calling metrics by operation type.
Maps each event type within the phase to its complete aggregate metrics, including detailed token consumption breakdown with cache statistics and comprehensive function calling metrics data. This comprehensive aggregation enables deep analysis of resource utilization patterns and operation quality across the entire phase.
The partial record structure reflects that not all possible event types may occur during phase execution. Only operations that were actually performed will have entries in this mapping.
The aggregate data supports cost analysis (via token usage), reliability assessment (via function calling metrics), and optimization opportunities (via cache hit rates and failure patterns).
Generated authentication and authorization decorators for role-based access control.
Contains the complete set of NestJS parameter decorators that provide automatic authentication and authorization functionality for different user roles. Each decorator includes its implementation code, associated provider functions, and payload type definitions that enable seamless integration of role-based security into Controller methods.
These decorators eliminate the need for manual authentication logic in Controllers by automatically validating JWT tokens, checking user roles, and injecting authenticated user data as typed parameters, ensuring both security and developer productivity.
Results of compiling the generated implementation TypeScript files through the TypeScript compiler.
Contains the IAutoBeTypeScriptCompileResult from processing the generated implementation files through the TypeScript compilation pipeline. This compilation result validates the complete application code including service classes, business logic, data access layers, and all integration components to ensure the final implementation is syntactically correct and ready for execution.
Through the Realize agent's internal compiler feedback process, this result is typically successful as the agent iteratively refines the generated code based on compilation diagnostics. However, in rare cases where the compiler feedback iteration limit is exceeded, the result may indicate failure despite the agent's correction attempts. Such failure occurrences are extremely infrequent due to the sophisticated feedback mechanisms built into the Realize agent's code generation process.
Successful compilation indicates that the generated implementation is production-ready and represents a fully functional application that can be deployed immediately without any syntax or integration issues.
Generated NestJS controller implementations mapped by controller name.
Contains the complete set of controller classes that handle HTTP requests and responses for the REST API. Each key represents the controller name (e.g., "BbsArticlesController", "ShoppingOrdersController") and each value contains the full TypeScript source code for that controller.
These controllers implement all the API endpoints defined in the Interface phase, with proper request/response handling, validation, authentication checks, and service layer integration. They serve as the entry points for the application's business logic, delegating actual processing to the corresponding service classes while maintaining clean separation of concerns.
The generated controllers follow NestJS best practices including decorator usage, dependency injection, and proper error handling, ensuring the API layer is both robust and maintainable.
Timestamp when the event was created.
ISO 8601 formatted date-time string indicating when this event was emitted by the system. This timestamp is crucial for event ordering, performance analysis, and debugging the agent workflow execution timeline.
Format: "YYYY-MM-DDTHH:mm:ss.sssZ" (e.g., "2024-01-15T14:30:45.123Z")
Total elapsed time for the phase execution in milliseconds.
Measures the wall-clock duration from phase start to completion, encompassing all agent operations, self-healing spiral loops, compiler validations, and any retry attempts. This metric provides visibility into phase-level performance and enables identification of bottlenecks in the waterfall pipeline.
The elapsed time includes both active LLM processing and any overhead from compilation, validation, and orchestration logic. For detailed breakdown of time spent in specific operations, consult the individual operation events within the phase.
Generated implementation functions
Contains the complete set of TypeScript implementation functions including service classes, business logic methods, data access objects, and integration code. Each key represents the function name and each value contains the actual implementation code that brings the designed system to life.
The implementation functions bridge the gap between API specifications and database schemas, providing the concrete business logic that makes the application functional and ready for deployment.
A unique identifier for the event.
Final state machine step counter value for the phase.
Records the terminal step number from the phase's state machine, which increments monotonically during execution and invalidates cached state when operations need to be redone. This step counter enables the frontend to detect when previously completed operations have been invalidated by spiral loop corrections, ensuring UI consistency with the actual generation state.
The step value provides a temporal marker for the phase completion, allowing correlation with intermediate operation events that share the same step number.
Unique identifier for the event type.
A literal string that discriminates between different event types in the AutoBE system. This field enables TypeScript's discriminated union feature, allowing type-safe event handling through switch statements or conditional checks.
Examples: "analyzeWrite", "prismaSchema", "interfaceOperation", "testScenario"
Event fired when the Realize agent completes the implementation of business logic and service layer code, finalizing the entire vibe coding pipeline.
This event represents the successful completion of the final phase in the vibe coding workflow, where all previous design artifacts converge into executable software. The Realize agent's completion marks the transformation of requirements, database schemas, API specifications, and test scenarios into a fully functional application ready for deployment.
The completion of the Realize phase represents the culmination of the entire automated development process, delivering working software that accurately implements business requirements while maintaining consistency across all architectural layers.
Author
Samchon