@autobe/agent 0.16.1 → 0.18.0

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

@@ -0,0 +1,276 @@
+export interface IAutoBeRealizeWriteApplication {
+    coding: (next: IAutoBeRealizeWriteApplication.IProps) => void;
+}
+export declare namespace IAutoBeRealizeWriteApplication {
+    interface IProps {
+        /**
+         * Step 1.
+         *
+         * 🧠 Provider Function Implementation Plan
+         *
+         * This field outlines the strategic plan for implementing the provider
+         * function according to the Realize Coder Agent specification. Before
+         * writing the actual code, think through the logic and structure.
+         *
+         * The plan MUST follow MANDATORY SCHEMA-FIRST APPROACH:
+         *
+         * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION (MOST CRITICAL):
+         *
+         * - EXAMINE the actual Prisma schema model definition
+         * - LIST EVERY field that exists in the model with exact types
+         * - EXPLICITLY NOTE fields that DO NOT exist (e.g., "Note: deleted_at field
+         *   DOES NOT EXIST")
+         * - Common assumption errors to avoid: `deleted_at`, `created_by`,
+         *   `updated_by`, `is_deleted`, `is_active`
+         *
+         * 📋 STEP 2 - FIELD INVENTORY:
+         *
+         * - List ONLY fields confirmed to exist in schema
+         * - Example: "Verified fields in user model: id (String), email (String),
+         *   created_at (DateTime), updated_at (DateTime)"
+         * - Example: "Fields that DO NOT exist: deleted_at, is_active, created_by"
+         *
+         * 📋 STEP 3 - FIELD ACCESS STRATEGY:
+         *
+         * - Plan which verified fields will be used in select, update, create
+         *   operations
+         * - For complex operations with type errors, plan to use separate queries
+         *   instead of nested operations
+         *
+         * 📋 STEP 4 - TYPE COMPATIBILITY:
+         *
+         * - Plan DateTime to ISO string conversions using toISOStringSafe()
+         * - Plan handling of nullable vs required fields
+         *
+         * 📋 STEP 5 - IMPLEMENTATION APPROACH:
+         *
+         * - 🧩 Required business entities (e.g., users, posts, logs) and their
+         *   relationships
+         * - 🛠 Operations needed to fulfill the business scenario (e.g., fetch,
+         *   create, update) using ONLY verified fields
+         * - 🔄 Data dependencies between steps (e.g., use userId to fetch related
+         *   data)
+         * - ✅ Validation points (based on business rules, not field presence)
+         * - 🚧 Error and edge cases that must be handled explicitly (e.g., missing
+         *   records)
+         * - 🏗 Structure: always a single `async function`, using only `parameters`
+         *   and `body`
+         *
+         * ⚠️ Important Constraints:
+         *
+         * - Do NOT perform input validation — assume `parameters` and `body` are
+         *   already valid
+         * - Use `typia.random<T>()` with an explanatory comment if logic can't be
+         *   implemented
+         * - Never use `any` or make assumptions without sufficient context
+         * - Use only allowed imports — DTOs and Prisma types
+         * - Use `MyGlobal.prisma` for DB access and respect Prisma typing rules
+         *
+         * ⚠️ TypeScript-specific considerations:
+         *
+         * - Do **not** use native `Date` objects directly; always convert all dates
+         *   using `toISOStringSafe()` and brand as `string &
+         *   tags.Format<'date-time'>`. This rule applies throughout all phases.
+         * - Prefer `satisfies` for DTO conformance instead of unsafe `as` casts
+         * - Avoid weak typing such as `any`, `as any`, or `satisfies any`
+         * - Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where
+         *   applicable
+         *
+         * ✅ Example Structure:
+         *
+         * ```ts
+         * export async function doSomething(
+         *   user: { id: string & tags.Format<"uuid">; type: string },
+         *   parameters: IParams,
+         *   body: IBody
+         * ): Promise<IReturn> {
+         *   const { id } = parameters;
+         *   const { name } = body;
+         *   const user = await MyGlobal.prisma.users.findFirst({ where: { id } });
+         *   if (!user) throw new Error("User not found");
+         *   ...
+         *   return result;
+         * }
+         * ```
+         *
+         * 🔍 Feasibility Analysis Requirement:
+         *
+         * - Before generating any code, the agent **must analyze** whether the
+         *   requested implementation is **feasible based on the given Prisma schema
+         *   and DTO types**.
+         * - If required fields or relationships are **missing or incompatible**, the
+         *   plan should explicitly state that the implementation is **not
+         *   possible** with the current schema/DTO, and no code should be generated
+         *   in later stages.
+         * - In such cases, only a detailed **comment in the `implementationCode`**
+         *   should be returned explaining why the logic cannot be implemented.
+         *
+         * 🔥 Error Handling Plan:
+         *
+         * If an error is expected or encountered during implementation:
+         *
+         * - Clearly document the error message(s) and TypeScript error codes.
+         * - Analyze the root cause (e.g., type mismatch, missing field, nullability
+         *   issue).
+         * - Define concrete steps to resolve the issue, such as:
+         *
+         *   - Adjusting type declarations or using Prisma-generated input types.
+         *   - Using `?? undefined` to normalize nullable fields.
+         *   - Applying correct relation handling (e.g., `connect` instead of direct
+         *       foreign key assignment).
+         *   - Ensuring all date fields use `.toISOString()` and proper branding.
+         * - Include fallback or workaround plans if a direct fix is complex.
+         * - If no error is present, simply omit this section.
+         *
+         * This plan ensures the function will:
+         *
+         * - Respect the global architecture and coding conventions
+         * - Be safe, predictable, and aligned with upstream logic
+         */
+        plan: string;
+        /**
+         * Step 2.
+         *
+         * The Prisma schema string that will be used to validate the implementation
+         * logic in this file.
+         *
+         * You must **explicitly specify only the relevant models and fields** from
+         * your full schema that are used in this implementation. This ensures that
+         * your logic is aligned with the expected database structure without
+         * accidentally introducing unrelated fields or models.
+         *
+         * ⚠️ Important: The value of this field must be a valid Prisma schema
+         * string containing only the models used in this code — not the entire
+         * schema.
+         *
+         * This acts as a safeguard against:
+         *
+         * - Forgetting required fields used in this implementation
+         * - Including fields or models that are not actually used
+         */
+        prisma_schemas: string;
+        /**
+         * Step 3.
+         *
+         * Draft WITHOUT using native Date type.
+         *
+         * This is the initial drafting phase where you outline the basic skeleton
+         * of the function. CRITICAL: This draft must NEVER use the native Date
+         * type.
+         *
+         * - The function signature must correctly include `user`, `parameters`, and
+         *   `body` arguments.
+         * - Design the main flow of business logic, such as DB fetches and early
+         *   returns based on conditions.
+         * - Mark any incomplete or missing parts clearly with placeholders (e.g.,
+         *   comments or temporary values).
+         *
+         * ⚠️ Import rules:
+         *
+         * - Do NOT add any new import statements manually.
+         * - All necessary imports are provided globally or by the system
+         *   automatically.
+         * - Writing import statements directly is prohibited and may cause compile
+         *   errors. If import errors occur, check your environment configuration.
+         *
+         * ✅ Requirements:
+         *
+         * - Avoid using the `any` type at all costs to ensure type safety.
+         * - NEVER declare variables with `: Date` type
+         * - ALWAYS use `string & tags.Format<'date-time'>` for date values
+         * - Use `toISOStringSafe(new Date())` for current timestamps
+         * - Maintain a single-function structure; avoid using classes.
+         */
+        draft_without_date_type: string;
+        /**
+         * Step 4.
+         *
+         * A refined version of the draft with improved completeness.
+         *
+         * - Replace placeholder logic with real DTO-conformant operations.
+         * - Add error handling (`throw new Error(...)`) where necessary.
+         * - Begin resolving structural or type mismatches.
+         *
+         * ✅ Requirements:
+         *
+         * - Use `satisfies` to ensure DTO conformity.
+         * - Avoid unsafe `as` casts unless only for branding or literal narrowing.
+         * - Use `toISOStringSafe()` for all date conversions (NOT `.toISOString()`).
+         * - Ensure all object keys strictly conform to the expected type definitions.
+         */
+        review: string;
+        /**
+         * 🛠 Phase 4-2: With compiler feedback (optional)
+         *
+         * A correction pass that applies fixes for compile-time errors that arose
+         * during the review stage (if any).
+         *
+         * ✅ Must:
+         *
+         * - Only include this field if TypeScript errors are detected in the Review
+         *   phase.
+         * - Resolve all TypeScript errors without using `as any`.
+         * - Provide safe brand casting only if required (e.g., `as string &
+         *   tags.Format<'uuid'>`).
+         * - If no TypeScript errors exist, this field MUST contain the text: "No
+         *   TypeScript errors detected - skipping this phase"
+         */
+        withCompilerFeedback: string;
+        /**
+         * Step 5.
+         *
+         * The complete and fully correct TypeScript function implementation.
+         *
+         * - Passes strict type checking without errors.
+         * - Uses only safe branding or literal type assertions.
+         * - Converts all date values properly using `toISOStringSafe()`.
+         * - Follows DTO structures using `satisfies`.
+         * - Avoids any weak typing such as `any`, `as any`, or `satisfies any`.
+         * - Uses only allowed imports (e.g., from `../api/structures` and
+         *   `MyGlobal.prisma`).
+         * - NEVER creates intermediate variables for Prisma operations.
+         *
+         * ⚠️ Fallback Behavior:
+         *
+         * - If the `plan` phase explicitly determines that the requested logic is
+         *   **not feasible** due to mismatches or limitations in the provided
+         *   Prisma schema and DTO types:
+         *
+         *   - The implementation must still return a syntactically valid function.
+         *   - In such cases, return mock data using `typia.random<T>()` wrapped in the
+         *       correct structure, along with a comment explaining the limitation.
+         *
+         *   Example fallback:
+         *
+         * ```ts
+         *   // ⚠️ Cannot implement logic due to missing relation between A and B
+         *   export async function someFunction(...) {
+         *     return typia.random<IReturn>(); // mocked output
+         *   }
+         * ```
+         *
+         * ⚠️ Prohibited Practices:
+         *
+         * - Do NOT add or modify import statements manually. Imports are handled
+         *   automatically by the system.
+         * - Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.
+         * - Do NOT assign native `Date` objects directly; always convert them using
+         *   `toISOStringSafe()`.
+         * - Do NOT use unsafe type assertions except for safe branding or literal
+         *   narrowing.
+         * - Do NOT write code outside the single async function structure (e.g., no
+         *   classes or multiple functions).
+         * - Do NOT perform any input validation — assume all inputs are already
+         *   validated.
+         * - Do NOT use dynamic import expressions (`import()`); all imports must be
+         *   static.
+         * - Do NOT use Prisma-generated input types; always use types from
+         *   `../api/structures`.
+         * - Do NOT use `Object.prototype.hasOwnProperty.call()` for field checks.
+         * - Do NOT escape newlines or quotes in the implementation string (e.g., no
+         *   `\\n` or `\"`); use a properly formatted template literal with actual
+         *   line breaks instead.
+         */
+        implementationCode: string;
+    }
+}

package/lib/orchestrate/test/histories/transformTestCorrectHistories.d.ts

@@ -0,0 +1,4 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
+export declare const transformTestCorrectHistories: (func: IAutoBeTestFunction, failure: IAutoBeTypeScriptCompileResult.IFailure) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/test/histories/transformTestHistories.d.ts

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

package/lib/orchestrate/test/histories/transformTestScenarioHistories.d.ts

@@ -0,0 +1,3 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+export declare const transformTestScenarioHistories: (entire: AutoBeOpenApi.IOperation[], include: AutoBeOpenApi.IOperation[], exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/test/histories/transformTestWriteHistories.d.ts

@@ -0,0 +1,8 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeTestScenario } from "@autobe/interface";
+import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
+export declare function transformTestWriteHistories(scenario: AutoBeTestScenario, artifacts: IAutoBeTestScenarioArtifacts): Array<IAgenticaHistoryJson.ISystemMessage>;
+export declare namespace transformTestWriteHistories {
+    function structures(artifacts: IAutoBeTestScenarioArtifacts): string;
+    function functional(artifacts: IAutoBeTestScenarioArtifacts): string;
+}

package/lib/orchestrate/test/orchestrateTestScenario.d.ts

@@ -1,4 +1,4 @@
-import { AutoBeTestScenarioEvent } from "@autobe/interface";
+import { AutoBeTestScenario } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateTestScenario<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>): Promise<AutoBeTestScenarioEvent>;
+export declare function orchestrateTestScenario<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>): Promise<AutoBeTestScenario[]>;

package/lib/orchestrate/test/structures/IAutoBeTestScenarioApplication.d.ts

@@ -1,4 +1,5 @@
-import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeOpenApi, SnakePattern } from "@autobe/interface";
+import { tags } from "typia";
 export interface IAutoBeTestScenarioApplication {
     /**
      * Make test scenarios for the given endpoints.
@@ -28,7 +29,7 @@ export declare namespace IAutoBeTestScenarioApplication {
          * Each scenario represents a specific test case for the same `path` and
          * `method`.
          */
-        scenarios: IScenario[];
+        scenarios: IScenario[] & tags.MinItems<1>;
     }
     /**
      * Represents a test scenario for a single API operation.
@@ -56,36 +57,36 @@ export declare namespace IAutoBeTestScenarioApplication {
          *
          * ## Naming Convention
          *
-         * - Must start with `test_` prefix (mandatory requirement)
-         * - Use snake_case formatting throughout
-         * - Include the primary user action (create, get, update, delete, list, etc.)
-         * - Specify the target resource (user, product, order, profile, etc.)
-         * - Add scenario-specific context (valid_data, invalid_email, not_found,
-         *   etc.)
+         * MUST use snake_case naming convention.
+         *
+         * - Must start with `test_api_` prefix (mandatory requirement)
+         * - ALWAYS start with business feature, NOT action verbs
+         * - Business feature comes first, followed by scenario context
+         * - Embed action verbs within the scenario description, not at the beginning
          *
          * ## Content Structure
          *
          * Function names should follow this pattern:
-         * `test_[user_action]_[resource]_[scenario_context]`
+         * `test_api_[core_feature]_[specific_scenario]`
          *
          * Where:
          *
-         * - `user_action`: What the user is trying to do
-         * - `resource`: What the user is interacting with
-         * - `scenario_context`: The specific situation or condition
+         * - `core_feature`: The main business feature or entity being tested
+         *   (customer, seller, cart, push_message, etc.)
+         * - `specific_scenario`: The specific operation or scenario context
+         *   (join_verification_not_found, login_success,
+         *   moderator_assignment_update, discountable_ticket_duplicated,
+         *   csv_export, etc.)
          *
-         * ## User-Focused Examples
+         * ## Business Feature-Based Examples
          *
-         * - `test_create_user_profile_with_complete_information` - User providing all
-         *   available profile data
-         * - `test_retrieve_user_profile_when_profile_exists` - User accessing their
-         *   existing profile
-         * - `test_update_user_email_with_valid_new_address` - User changing their
-         *   email to a valid new one
-         * - `test_delete_user_account_when_user_lacks_permission` - User attempting
-         *   account deletion without authorization
-         * - `test_search_user_profiles_with_pagination_preferences` - User browsing
-         *   profiles with specific pagination
+         * - `test_api_customer_join_verification_not_found` - Customer join
+         *   verification when verification code not found
+         * - `test_api_seller_login` - Seller login operation
+         * - `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket
+         *   with duplication scenario
+         * - `test_api_push_message_csv` - Push message functionality with CSV format
+         * - `test_api_product_review_update` - Product review update operation
          *
          * ## Clarity Guidelines
          *
@@ -104,7 +105,7 @@ export declare namespace IAutoBeTestScenarioApplication {
          * - Don't imply dependency on other API operations
          * - Represent complete user interactions
          */
-        functionName: string;
+        functionName: string & SnakePattern;
         /**
          * A list of other API endpoints that this scenario logically depends on.
          *

package/lib/orchestrate/test/structures/IAutoBeTestWriteApplication.d.ts

@@ -1,3 +1,4 @@
+import { SnakePattern } from "@autobe/interface";
 export interface IAutoBeTestWriteApplication {
     /**
      * Main entry point for AI Function Call - generates complete E2E test code.
@@ -37,7 +38,7 @@ export declare namespace IAutoBeTestWriteApplication {
          * Workflow: Scenario analysis → Domain identification → Test organization
          * structure
          */
-        domain: string;
+        domain: string & SnakePattern;
         /**
          * Step 3: Initial TypeScript E2E test code implementation.
          *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobe/agent",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "AI backend server code generator",
   "main": "lib/index.js",
   "author": "Wrtn Technologies",
@@ -20,15 +20,15 @@
     "README.md"
   ],
   "dependencies": {
-    "@agentica/core": "^0.30.8",
+    "@agentica/core": "^0.31.1",
     "@prisma/internals": "^6.7.0",
-    "@samchon/openapi": "^4.6.0",
-    "openai": "^5.2.0",
+    "@samchon/openapi": "^4.7.1",
+    "openai": "^5.12.2",
     "tstl": "^3.0.0",
-    "typia": "^9.6.0",
+    "typia": "^9.7.1",
     "uuid": "^11.1.0",
-    "@autobe/interface": "^0.16.1",
-    "@autobe/utils": "^0.16.1"
+    "@autobe/interface": "^0.18.0",
+    "@autobe/utils": "^0.18.0"
   },
   "devDependencies": {
     "@rollup/plugin-json": "^6.1.0",
@@ -39,9 +39,9 @@
     "rollup": "^4.40.1",
     "ts-node": "^10.9.2",
     "ts-patch": "^3.3.0",
-    "typescript": "~5.8.3",
-    "@autobe/compiler": "^0.16.1",
-    "@autobe/filesystem": "^0.16.1"
+    "typescript": "~5.9.2",
+    "@autobe/compiler": "^0.18.0",
+    "@autobe/filesystem": "^0.18.0"
   },
   "keywords": [
     "ai",

package/src/AutoBeAgent.ts

@@ -1,4 +1,8 @@
-import { IAgenticaVendor, MicroAgentica } from "@agentica/core";
+import {
+  IAgenticaTokenUsageJson,
+  IAgenticaVendor,
+  MicroAgentica,
+} from "@agentica/core";
 import {
   AutoBeAssistantMessageHistory,
   AutoBeHistory,
@@ -17,6 +21,7 @@ import { AutoBeState } from "./context/AutoBeState";
 import { AutoBeTokenUsage } from "./context/AutoBeTokenUsage";
 import { createAgenticaHistory } from "./factory/createAgenticaHistory";
 import { createAutoBeController } from "./factory/createAutoBeApplication";
+import { createAutoBeContext } from "./factory/createAutoBeContext";
 import { createAutoBeState } from "./factory/createAutoBeState";
 import { transformFacadeStateMessage } from "./orchestrate/facade/transformFacadeStateMessage";
 import { IAutoBeProps } from "./structures/IAutoBeProps";
@@ -118,23 +123,21 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
     const compiler = new Singleton(async () =>
       props.compiler(compilerListener),
     );
-    this.context_ = {
-      vendor,
+    this.context_ = createAutoBeContext({
       model: props.model,
+      vendor: props.vendor,
       config: {
         backoffStrategy: randomBackoffStrategy,
         ...props.config,
       },
       compiler: () => compiler.get(),
       compilerListener,
-      histories: () => this.histories_,
       state: () => this.state_,
-      usage: () => this.getTokenUsage(),
       files: (options) => this.getFiles(options),
-      dispatch: (event) => {
-        this.dispatch(event).catch(() => {});
-      },
-    } satisfies AutoBeContext<Model>;
+      histories: () => this.histories_,
+      usage: () => this.usage_,
+      dispatch: (event) => this.dispatch(event),
+    });
     this.agentica_ = new MicroAgentica({
       vendor,
       model: props.model,
@@ -147,7 +150,6 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
           execute: () => transformFacadeStateMessage(this.state_),
         },
       },
-      tokenUsage: this.usage_.facade,
       controllers: [
         createAutoBeController({
           model: props.model,
@@ -156,6 +158,7 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
       ],
     });
 
+    // HISTORIES MANIPULATION
     this.agentica_.getHistories().push(
       ...this.histories_
         .map((history) =>
@@ -166,6 +169,34 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
         )
         .filter((h) => h !== null),
     );
+
+    // TRACE FACADE TOKEN USAGE
+    let previous: IAgenticaTokenUsageJson.IComponent = this.agentica_
+      .getTokenUsage()
+      .toJSON().aggregate;
+    const increment = () => {
+      const current: IAgenticaTokenUsageJson.IComponent = this.agentica_
+        .getTokenUsage()
+        .toJSON().aggregate;
+      this.usage_.facade.increment({
+        total: current.total - previous.total,
+        input: {
+          total: current.input.total - previous.input.total,
+          cached: current.input.cached - previous.input.cached,
+        },
+        output: {
+          total: current.output.total - previous.output.total,
+          reasoning: current.output.reasoning - previous.output.reasoning,
+          accepted_prediction:
+            current.output.accepted_prediction -
+            previous.output.accepted_prediction,
+          rejected_prediction:
+            current.output.rejected_prediction -
+            previous.output.rejected_prediction,
+        },
+      });
+      previous = current;
+    };
     this.agentica_.on("assistantMessage", async (message) => {
       const start = new Date();
       const history: AutoBeAssistantMessageHistory = {
@@ -175,6 +206,7 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
         created_at: start.toISOString(),
         completed_at: new Date().toISOString(),
       };
+      increment();
       this.histories_.push(history);
       this.dispatch({
         type: "assistantMessage",
@@ -182,6 +214,9 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
         created_at: history.created_at,
       }).catch(() => {});
     });
+    this.agentica_.on("call", async () => {
+      increment();
+    });
     this.agentica_.on("request", (e) => {
       if (e.body.parallel_tool_calls !== undefined)
         delete e.body.parallel_tool_calls;

package/src/AutoBeMockAgent.ts

@@ -88,7 +88,24 @@ export class AutoBeMockAgent extends AutoBeAgentBase implements IAutoBeAgent {
     const take = async (
       type: "analyze" | "prisma" | "interface" | "test" | "realize",
     ): Promise<void> => {
-      for (const s of this.getEventSnapshots(type)) {
+      const snapshots: AutoBeEventSnapshot[] | null =
+        this.getEventSnapshots(type);
+      if (snapshots === null) {
+        this.histories_.push(userMessage);
+        this.histories_.push({
+          id: v4(),
+          type: "assistantMessage",
+          text: [
+            "The histories are prepared until current state.",
+            "",
+            "Thanks for using AutoBE!",
+          ].join("\n"),
+          created_at: new Date().toISOString(),
+          completed_at: new Date().toISOString(),
+        });
+        return;
+      }
+      for (const s of snapshots) {
         const time: number = sleepMap[s.event.type] ?? 500;
         await sleep_for(randint(time * 0.2, time * 1.8));
         void this.dispatch(s.event).catch(() => {});
@@ -117,8 +134,8 @@ export class AutoBeMockAgent extends AutoBeAgentBase implements IAutoBeAgent {
 
   private getEventSnapshots(
     state: "analyze" | "prisma" | "interface" | "test" | "realize",
-  ): AutoBeEventSnapshot[] {
-    return this.props_.preset[state];
+  ): AutoBeEventSnapshot[] | null {
+    return this.props_.preset[state] ?? null;
   }
 }
 export namespace AutoBeMockAgent {
@@ -130,17 +147,20 @@ export namespace AutoBeMockAgent {
   }
   export interface IPreset {
     histories: AutoBeHistory[];
-    analyze: AutoBeEventSnapshot[];
-    prisma: AutoBeEventSnapshot[];
-    interface: AutoBeEventSnapshot[];
-    test: AutoBeEventSnapshot[];
-    realize: AutoBeEventSnapshot[];
+    analyze?: AutoBeEventSnapshot[] | null;
+    prisma?: AutoBeEventSnapshot[] | null;
+    interface?: AutoBeEventSnapshot[] | null;
+    test?: AutoBeEventSnapshot[] | null;
+    realize?: AutoBeEventSnapshot[] | null;
   }
 }
 
-const sleepMap: Partial<Record<AutoBeEvent.Type, number>> = {
+const sleepMap: Record<AutoBeEvent.Type, number> = {
+  userMessage: 1_000,
+  assistantMessage: 1_000,
   // ANALYZE
   analyzeStart: 1_000,
+  analyzeScenario: 1_000,
   analyzeWrite: 500,
   analyzeReview: 300,
   analyzeComplete: 1_000,
@@ -148,20 +168,25 @@ const sleepMap: Partial<Record<AutoBeEvent.Type, number>> = {
   prismaStart: 1_000,
   prismaComponents: 1_000,
   prismaSchemas: 500,
+  prismaInsufficient: 1_000,
+  prismaReview: 500,
   prismaValidate: 2_000,
   prismaCorrect: 500,
-  prismaInsufficient: 1_000,
   prismaComplete: 1_000,
   // INTERFACE
   interfaceStart: 1_000,
+  interfaceGroups: 1_000,
   interfaceEndpoints: 1_000,
   interfaceOperations: 400,
+  interfaceOperationsReview: 400,
+  interfaceAuthorization: 400,
   interfaceSchemas: 400,
+  interfaceSchemasReview: 400,
   interfaceComplement: 2_000,
   interfaceComplete: 1_000,
   // TEST
   testStart: 1_000,
-  testScenario: 1_000,
+  testScenarios: 40,
   testWrite: 40,
   testValidate: 100,
   testCorrect: 100,
@@ -175,5 +200,10 @@ const sleepMap: Partial<Record<AutoBeEvent.Type, number>> = {
   realizeAuthorizationStart: 1_000,
   realizeAuthorizationWrite: 200,
   realizeAuthorizationValidate: 200,
+  realizeAuthorizationCorrect: 200,
   realizeAuthorizationComplete: 1_000,
+  realizeTestStart: 1_000,
+  realizeTestReset: 2_500,
+  realizeTestOperation: 400,
+  realizeTestComplete: 1_000,
 };