@autobe/agent 0.16.1 → 0.18.0

package/src/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.ts

@@ -0,0 +1,108 @@
+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 namespace IAutoBePrismaReviewApplication {
+  export 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[];
+  }
+}

package/src/orchestrate/prisma/structures/IAutoBePrismaSchemaApplication.ts

@@ -0,0 +1,101 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
+
+export interface IAutoBePrismaSchemaApplication {
+  /**
+   * Generates comprehensive Prisma schema files based on detailed requirements
+   * analysis.
+   *
+   * Creates multiple organized schema files following enterprise patterns
+   * including proper domain separation, relationship modeling, snapshot
+   * patterns, inheritance, materialized views, and comprehensive documentation.
+   * The generated schemas implement best practices for scalability,
+   * maintainability, and data integrity.
+   *
+   * @param props Properties containing the file
+   */
+  makePrismaSchemaFile(props: IAutoBePrismaSchemaApplication.IProps): void;
+}
+export namespace IAutoBePrismaSchemaApplication {
+  export interface IProps {
+    /**
+     * Strategic database design analysis and planning.
+     *
+     * AI analyzes the target component and business requirements to formulate a
+     * comprehensive database design strategy. This planning phase is crucial
+     * for creating well-structured, normalized schemas that align with business
+     * objectives. The AI must define table structures, relationships, indexing
+     * strategies, and data integrity constraints before proceeding to schema
+     * implementation.
+     *
+     * **Key Considerations:**
+     *
+     * - **Assignment Validation**: Extract targetComponent.tables as the complete
+     *   specification
+     * - **Table Count**: Must create exactly targetComponent.tables.length models
+     * - **Other Components**: Identify already-created tables for foreign key
+     *   references only
+     * - **Normalization**: Strict adherence to 1NF, 2NF, 3NF principles
+     * - **Snapshot Architecture**: Design for historical data preservation and
+     *   audit trails
+     * - **Junction Tables**: Plan M:N relationships with proper naming
+     *   ({table1}_{table2})
+     * - **Materialized Views**: Identify needs for mv_ prefixed denormalized
+     *   tables
+     *
+     * Workflow: Component analysis → Strategic planning → Design rationale
+     */
+    plan: string;
+
+    /**
+     * Production-ready Prisma schema models generated based on the strategic
+     * plan.
+     *
+     * Contains a structured Abstract Syntax Tree (AST) representation of all
+     * database tables for the target component. Each model implements the
+     * planned table structure, relationships, indexes, and constraints using
+     * the AutoBePrisma.IModel interface. These models are designed to be
+     * production-ready from the initial generation, following all best
+     * practices and normalization principles.
+     *
+     * **Implementation Requirements:**
+     *
+     * - **Model Count**: Exactly matches targetComponent.tables.length (plus any
+     *   junction tables)
+     * - **Table Names**: EXACT names from targetComponent.tables - no
+     *   modifications allowed
+     * - **Primary Keys**: Always UUID type with field name "id"
+     * - **Foreign Keys**: Proper IRelation configurations for all relationships
+     * - **Business Fields**: Only raw data fields - no calculated or derived
+     *   values
+     * - **Data Types**: Limited to: uuid, string, int, double, datetime, boolean,
+     *   uri
+     * - **Relationships**: Correct patterns for 1:1, 1:N, and M:N relationships
+     * - **Indexes**:
+     *
+     *   - UniqueIndexes: Business constraints and composite unique keys
+     *   - PlainIndexes: Multi-column query optimization (never single FK indexes)
+     *   - GinIndexes: Full-text search on appropriate string fields
+     * - **Materialized Views**: Tables prefixed with "mv_" have material flag set
+     *   to true
+     * - **Documentation**: Comprehensive English descriptions with business
+     *   context
+     *
+     * **Quality Standards:**
+     *
+     * - **Normalization**: Strict adherence to 3NF (Third Normal Form)
+     * - **No Denormalization**: Except in materialized views (mv_ tables)
+     * - **Referential Integrity**: All foreign keys reference valid existing
+     *   tables
+     * - **Temporal Fields**: Consistent created_at, updated_at, deleted_at
+     *   patterns
+     * - **Snapshot Support**: Proper historical data preservation where needed
+     * - **Performance Ready**: Optimized index strategy for expected query
+     *   patterns
+     *
+     * The generated models will undergo review by a separate specialized agent
+     * to ensure compliance with all requirements and best practices.
+     */
+    models: AutoBePrisma.IModel[] & tags.MinItems<1>;
+  }
+}

package/src/orchestrate/realize/{transformRealizeAuthorization.ts → histories/transformRealizeAuthorization.ts}

@@ -1,13 +1,16 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeRole } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../context/AutoBeContext";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 
-export const transformRealizeAuthorizationHistories = (
-  ctx: AutoBeContext<ILlmSchema.Model>,
-  role: string,
+export const transformRealizeAuthorizationHistories = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  role: AutoBeAnalyzeRole,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
@@ -24,8 +27,9 @@ export const transformRealizeAuthorizationHistories = (
       type: "systemMessage",
       text: [
         "## Role",
-        "",
-        role,
+        "```json",
+        JSON.stringify(role),
+        "```",
         "",
         "## Prisma Schema",
         "",
@@ -35,9 +39,9 @@ export const transformRealizeAuthorizationHistories = (
         "",
         "Please follow this naming convention for the authorization components:",
         "",
-        `- Provider Name: ${role}Authorize (e.g. ${role}Authorize)`,
-        `- Decorator Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Auth (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Auth)`,
-        `- Payload Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Payload (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Payload)`,
+        `- Provider Name: ${role.name}Authorize (e.g. ${role.name}Authorize)`,
+        `- Decorator Name: ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Auth (e.g. ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Auth)`,
+        `- Payload Name: ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Payload (e.g. ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Payload)`,
       ].join("\n"),
     },
   ];

package/src/orchestrate/realize/{transformRealizeAuthorizationCorrectHistories.ts → histories/transformRealizeAuthorizationCorrectHistories.ts}

@@ -6,11 +6,13 @@ import {
 import { ILlmSchema } from "@samchon/openapi";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../context/AutoBeContext";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 
-export const transformRealizeAuthorizationCorrectHistories = (
-  ctx: AutoBeContext<ILlmSchema.Model>,
+export const transformRealizeAuthorizationCorrectHistories = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
   auth: AutoBeRealizeAuthorization,
   templateFiles: Record<string, string>,
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -86,9 +88,9 @@ export const transformRealizeAuthorizationCorrectHistories = (
         "",
         "Please follow this naming convention for the authorization components:",
         "",
-        `- Provider Name: ${auth.role.toLowerCase()}Authorize (e.g. ${auth.role.toLowerCase()}Authorize)`,
-        `- Decorator Name: ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Auth (e.g. ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Auth)`,
-        `- Payload Name: ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Payload (e.g. ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Payload)`,
+        `- Provider Name: ${auth.role.name.toLowerCase()}Authorize (e.g. ${auth.role.name.toLowerCase()}Authorize)`,
+        `- Decorator Name: ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Auth (e.g. ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Auth)`,
+        `- Payload Name: ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Payload (e.g. ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Payload)`,
       ].join("\n"),
     },
   ];

package/src/orchestrate/realize/{transformRealizeCoderHistories.ts → histories/transformRealizeCoderHistories.ts}

@@ -5,16 +5,16 @@ import {
 } from "@autobe/interface";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
-import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
-import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenario } from "../orchestrateRealizeScenario";
+import { IAutoBeRealizeCompile } from "../structures/IAutoBeRealizeCompile";
 
 export const transformRealizeCoderHistories = (
   state: AutoBeState,
   previousCodes: IAutoBeRealizeCompile.Success[],
-  props: RealizePlannerOutput,
+  props: IAutoBeRealizeScenario,
   artifacts: IAutoBeTestScenarioArtifacts,
   previous: string | null,
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],

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

@@ -0,0 +1,47 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import {
+  AutoBeRealizeAuthorization,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
+
+export function transformRealizeCorrectHistories(props: {
+  state: AutoBeState;
+  scenario: IAutoBeRealizeScenarioApplication.IProps;
+  artifacts: IAutoBeTestScenarioArtifacts;
+  authorization: AutoBeRealizeAuthorization | null;
+  code: string;
+  diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+}): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> {
+  return [
+    ...transformRealizeWriteHistories(props),
+    {
+      id: v4(),
+      type: "assistantMessage",
+      text: [
+        `Below is the code you made before. It's also something to review.`,
+        "```typescript",
+        props.code,
+        "```",
+        `The code has a compilation error:`,
+        "```json",
+        JSON.stringify(props.diagnostic, null, 2),
+        "",
+      ].join("\n"),
+      created_at: new Date().toISOString(),
+    },
+    {
+      id: v4(),
+      type: "systemMessage",
+      text: `You are an expert TypeScript developer. You will review the code and correct`,
+      created_at: new Date().toISOString(),
+    },
+  ];
+}

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

@@ -0,0 +1,184 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization } from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+
+export const transformRealizeWriteHistories = (props: {
+  state: AutoBeState;
+  scenario: IAutoBeRealizeScenarioApplication.IProps;
+  artifacts: IAutoBeTestScenarioArtifacts;
+  authorization: AutoBeRealizeAuthorization | null;
+}): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  const [operation] = props.artifacts.document.operations;
+
+  const propsFields: string[] = [];
+
+  // payload 추가
+  if (props.authorization && operation.authorizationRole) {
+    propsFields.push(
+      `${operation.authorizationRole}: ${props.authorization.payload.name};`,
+    );
+  }
+
+  // parameters 추가
+  operation.parameters.forEach((parameter) => {
+    const format =
+      "format" in parameter.schema
+        ? ` & tags.Format<'${parameter.schema.format}'>`
+        : "";
+    propsFields.push(`${parameter.name}: ${parameter.schema.type}${format};`);
+  });
+
+  // body 추가
+  if (operation.requestBody?.typeName) {
+    propsFields.push(`body: ${operation.requestBody.typeName};`);
+  }
+
+  const input =
+    propsFields.length > 0
+      ? `props: {\n${propsFields.map((field) => `  ${field}`).join("\n")}\n}`
+      : `// No props parameter needed - function should have no parameters`;
+
+  if (props.state.analyze === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Requirement analysis is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the requirement analysis.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.prisma === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.analyze.step !== props.state.prisma.step)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.prisma.compiled.type !== "success")
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.interface === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Interface generation is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the interface generation.",
+        ].join(" "),
+      },
+    ];
+
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_TOTAL,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_ARTIFACT.replaceAll(
+        `{prisma_schemas}`,
+        JSON.stringify(props.state.prisma.schemas),
+      )
+        .replaceAll(`{artifacts_sdk}`, JSON.stringify(props.artifacts.sdk))
+        .replaceAll(`{artifacts_dto}`, JSON.stringify(props.artifacts.dto))
+        .replaceAll(`{input}`, input),
+    },
+
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "Write new code based on the following operation.",
+        "```json",
+        JSON.stringify(props.scenario),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        `I understand your request.`,
+        ``,
+        `To summarize:`,
+        `- I must **never use the native \`Date\` type** in any code or type definitions.`,
+        `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`,
+        `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`,
+        `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`,
+        ``,
+        `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`,
+        ``,
+        `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.`,
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        `I understand your request.`,
+        ``,
+        `To summarize:`,
+        `- I must **never use the native \`Date\` type** in any code or type definitions.`,
+        `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`,
+        `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`,
+        `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`,
+        ``,
+        `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`,
+        ``,
+        `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.`,
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/realize/internal/compile.ts

@@ -0,0 +1,84 @@
+import {
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeValidateEvent,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeRealizeCompile } from "../structures/IAutoBeRealizeCompile";
+
+export async function compile<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    authorizations: AutoBeRealizeAuthorization[];
+    providers: Record<string, string>;
+  },
+): Promise<
+  IAutoBeTypeScriptCompileResult.ISuccess | AutoBeRealizeValidateEvent
+> {
+  const prisma = ctx.state().prisma?.compiled;
+  const payloads: Record<string, string> = Object.fromEntries(
+    props.authorizations.map((el) => [el.payload.location, el.payload.content]),
+  );
+  const templateFiles = await getTemplates(ctx);
+  const nodeModules = prisma?.type === "success" ? prisma.nodeModules : {};
+  const compiler = await ctx.compiler();
+  const compiled = await compiler.typescript.compile({
+    files: {
+      ...nodeModules,
+      ...payloads,
+      ...Object.fromEntries(
+        Object.entries(await ctx.files({ dbms: "sqlite" })).filter(([key]) =>
+          key.startsWith("src"),
+        ),
+      ),
+      ...Object.fromEntries(
+        templateFiles.map((file) => [file.location, file.content]),
+      ),
+      ...props.providers,
+    },
+  });
+
+  if (compiled.type === "success") {
+    return compiled;
+  }
+
+  const event: AutoBeRealizeValidateEvent = {
+    type: "realizeValidate",
+    result: compiled,
+    files: Object.fromEntries(
+      compiled.type === "failure"
+        ? compiled.diagnostics.map((d) => [d.file, d.code])
+        : [],
+    ),
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  };
+
+  return event;
+}
+
+/**
+ * Loads template files for the realize agent These files are essential for the
+ * realize coder to pass compilation
+ *
+ * @param ctx Context of agent
+ * @returns Template file infomations
+ */
+async function getTemplates<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+): Promise<IAutoBeRealizeCompile.CodeArtifact[]> {
+  const compiler = await ctx.compiler();
+  const templateFiles = await compiler.realize.getTemplate();
+  const pathnames = ["src/MyGlobal.ts", "src/util/toISOStringSafe.ts"] as const;
+
+  return pathnames.map((pathname): IAutoBeRealizeCompile.CodeArtifact => {
+    return {
+      content: templateFiles[pathname],
+      result: "success",
+      location: pathname,
+      role: null, // template files doesn't have role.
+    } as const;
+  });
+}