@autobe/agent 0.19.1 → 0.21.0

package/lib/orchestrate/analyze/histories/transformAnalyzeReviewHistories.d.ts

@@ -0,0 +1,6 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare const transformAnalyzeReviewHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, allFiles: AutoBeAnalyzeFile[], myFile: AutoBeAnalyzeFile) => Array<IAgenticaHistoryJson.IUserMessage | IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/analyze/orchestrateAnalyzeReview.d.ts

@@ -2,4 +2,10 @@ import { AutoBeAnalyzeReviewEvent, AutoBeAnalyzeScenarioEvent, AutoBeProgressEve
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare const orchestrateAnalyzeReview: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, otherFiles: AutoBeAnalyzeFile[], myFile: AutoBeAnalyzeFile, progress: AutoBeProgressEventBase) => Promise<AutoBeAnalyzeReviewEvent>;
+export declare const orchestrateAnalyzeReview: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
+    scenario: AutoBeAnalyzeScenarioEvent;
+    allFiles: AutoBeAnalyzeFile[];
+    myFile: AutoBeAnalyzeFile;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+}) => Promise<AutoBeAnalyzeReviewEvent>;

package/lib/orchestrate/analyze/orchestrateAnalyzeWrite.d.ts

@@ -1,8 +1,10 @@
-import { AutoBeAnalyzeScenarioEvent, AutoBeAnalyzeWriteEvent } from "@autobe/interface";
+import { AutoBeAnalyzeScenarioEvent, AutoBeAnalyzeWriteEvent, AutoBeProgressEventBase } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare const orchestrateAnalyzeWrite: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, file: AutoBeAnalyzeFile.Scenario, progress: {
-    total: number;
-    completed: number;
+export declare const orchestrateAnalyzeWrite: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
+    scenario: AutoBeAnalyzeScenarioEvent;
+    file: AutoBeAnalyzeFile.Scenario;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
 }) => Promise<AutoBeAnalyzeWriteEvent>;

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

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

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

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

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

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

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

@@ -0,0 +1,60 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+/**
+ * Interface for reviewing and refining API endpoints through holistic analysis.
+ *
+ * This application performs comprehensive review of all endpoints generated
+ * through divide-and-conquer strategy, ensuring consistency, eliminating
+ * redundancy, and preventing over-engineering across the entire API surface.
+ */
+export interface IAutoBeInterfaceEndpointsReviewApplication {
+    /**
+     * Reviews and refines the complete collection of API endpoints.
+     *
+     * This method consolidates all endpoints generated independently by different
+     * groups and performs holistic review to:
+     * - Ensure naming consistency across all endpoints
+     * - Remove duplicate or overlapping endpoints
+     * - Eliminate over-engineered solutions
+     * - Standardize path structures and HTTP methods
+     * - Verify REST API design principles
+     *
+     * The review process examines the entire API as a cohesive system rather
+     * than individual endpoints, ensuring the final API is intuitive, maintainable,
+     * and follows best practices.
+     *
+     * @param next - The review results and refined endpoint collection
+     */
+    reviewEndpoints(next: IAutoBeInterfaceEndpointsReviewApplication.IProps): void;
+}
+export declare namespace IAutoBeInterfaceEndpointsReviewApplication {
+    interface IProps {
+        /**
+         * Comprehensive review analysis of all collected endpoints.
+         *
+         * Contains detailed findings from the holistic review including:
+         * - Identified inconsistencies in naming conventions
+         * - Duplicate endpoints that serve the same purpose
+         * - Over-engineered solutions that add unnecessary complexity
+         * - Violations of REST API design principles
+         * - Recommendations for improvement and standardization
+         *
+         * The review provides actionable feedback for creating a clean,
+         * consistent, and maintainable API structure.
+         */
+        review: string;
+        /**
+         * Refined collection of API endpoints after review and cleanup.
+         *
+         * The final optimized set of endpoints after:
+         * - Removing duplicates and redundant endpoints
+         * - Standardizing naming conventions across all paths
+         * - Simplifying over-engineered solutions
+         * - Ensuring consistent REST patterns
+         * - Aligning HTTP methods with their semantic meanings
+         *
+         * This collection represents the production-ready API structure
+         * that balances functionality with simplicity and maintainability.
+         */
+        endpoints: AutoBeOpenApi.IEndpoint[];
+    }
+}

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

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

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

@@ -128,5 +128,83 @@ export declare namespace IAutoBeInterfaceOperationsReviewApplication {
      * ```
      */
     interface IOperation extends Omit<AutoBeOpenApi.IOperation, "authorizationType"> {
+        /**
+         * Prisma schema models relevant to this operation.
+         *
+         * Contains the complete Prisma schema definitions for all entities involved
+         * in this operation, including their fields, relations, and database
+         * constraints. This enables comprehensive validation and schema-aware
+         * operation design.
+         *
+         * The schema information serves multiple critical purposes:
+         *
+         * - **Field Verification**: Ensures all referenced fields actually exist in
+         *   the database schema and have the correct types
+         * - **Relationship Validation**: Confirms that entity relationships are
+         *   properly defined and can support the operation's data access patterns
+         * - **Soft-Delete Detection**: For DELETE operations, identifies whether
+         *   entities have soft-delete fields (deleted_at, is_deleted, etc.) to
+         *   determine if the operation should perform logical deletion instead of
+         *   physical removal
+         * - **Constraint Awareness**: Understands unique constraints, required
+         *   fields, and default values to generate accurate request/response
+         *   schemas
+         *
+         * Example content might include:
+         *
+         * ```prisma
+         * model User {
+         *   id         String    @id @default(uuid())
+         *   email      String    @unique
+         *   name       String
+         *   deleted_at DateTime? // Indicates soft-delete capability
+         *   posts      Post[]
+         * }
+         * ```
+         *
+         * This schema context ensures operations are fully aligned with the actual
+         * database structure and business logic requirements.
+         */
+        prisma_schemas: string;
+        /**
+         * Primary Prisma model name for this operation.
+         *
+         * Identifies the main database table/model that this operation targets.
+         * This must match exactly with the Prisma model name defined in the schema.
+         * When soft deletion is specified, this model name indicates which table
+         * should be soft-deleted.
+         *
+         * For example:
+         * - In a "GET /users/:id" operation, this would be "User"
+         * - In a "POST /articles" operation, this would be "Article"
+         * - In a "DELETE /comments/:id" with soft delete, this specifies the "Comment" model to soft-delete
+         *
+         * This property is essential for:
+         * - Determining the primary entity for CRUD operations
+         * - Identifying which table to apply soft deletion to
+         * - Validating operations against the correct Prisma model
+         * - Generating appropriate database queries and validations
+         */
+        model_name: string;
+        /**
+         * Soft delete column name for the Prisma models.
+         *
+         * Specifies the column name used for soft deletion in the database tables
+         * associated with this operation. When set to a non-null value, it indicates
+         * that the related entities support soft deletion through this column
+         * (typically a timestamp field like `deleted_at` or `deletedAt`).
+         *
+         * When null, it means the entities involved in this operation use hard
+         * deletion or don't support deletion at all. This information is crucial
+         * for generating appropriate CRUD operations and ensuring data integrity
+         * policies are correctly implemented.
+         *
+         * Common soft delete patterns:
+         * - `"deleted_at"`: Records deletion timestamp
+         * - `"deletedAt"`: Camel-cased deletion timestamp
+         * - `"is_deleted"`: Boolean flag for deletion status
+         * - `null`: No soft deletion (hard delete only)
+         */
+        soft_delete_column: string | null;
     }
 }

package/lib/{agent/src/orchestrate/realize/internal/compile.d.ts → orchestrate/realize/internal/compileRealizeFiles.d.ts}

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

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

@@ -1,4 +1,4 @@
-import { AutoBeRealizeAuthorization, AutoBeRealizeCorrectEvent, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeProgressEventBase, AutoBeRealizeAuthorization, AutoBeRealizeCorrectEvent, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
@@ -8,9 +8,5 @@ export declare function orchestrateRealizeCorrect<Model extends ILlmSchema.Model
     scenario: IAutoBeRealizeScenarioApplication.IProps;
     code: string;
     diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
-    progress: IProgress;
+    progress: AutoBeProgressEventBase;
 }): Promise<AutoBeRealizeCorrectEvent>;
-export interface IProgress {
-    total: number;
-    completed: number;
-}

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

@@ -2,72 +2,6 @@ import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
-export interface IAutoBeRealizeScenario {
-    /**
-     * The name of the function to be generated.
-     *
-     * Derived from the Swagger path and method. The function name must be written
-     * in snake_case. It serves as the entry point in both code generation and
-     * test code.
-     *
-     * Once the function is generated, the function name and file name will be the
-     * same. The generated file will be located at
-     * `src/providers/${function_name}.ts`.
-     */
-    functionName: string;
-    /**
-     * Definition of path and query parameters extracted from the OpenAPI spec.
-     *
-     * Includes input values passed via URL path or query string. Used for type
-     * definitions, validation, and function signature construction.
-     */
-    parameters: AutoBeOpenApi.IParameter[];
-    /**
-     * Schema definition for the request body input.
-     *
-     * Extracted from the requestBody section of Swagger. Represents the input
-     * data passed in the body (e.g., JSON). Used for generating function
-     * arguments or DTOs.
-     */
-    inputSchema: AutoBeOpenApi.IRequestBody | null;
-    /**
-     * Schema definition for the response body.
-     *
-     * Extracted from the responses section of Swagger. Used to define the return
-     * type and expected output in test code.
-     */
-    outputSchema: AutoBeOpenApi.IResponseBody | null;
-    /**
-     * Natural language description of the function’s purpose.
-     *
-     * Extracted from the summary or description field of Swagger. Used for code
-     * documentation, test scenario generation, and conveying function intent.
-     */
-    description: string;
-    /**
-     * HTTP method information.
-     *
-     * Extracted from the Swagger operation method. Used to define the request
-     * type during code and test generation.
-     */
-    method: "get" | "post" | "put" | "delete" | "patch";
-    /**
-     * List of scenario descriptions for test code generation.
-     *
-     * Each scenario describes the expected behavior of the function under certain
-     * conditions. Used as a basis for TDD-style automated test generation.
-     */
-    testScenarios: string[];
-    /**
-     * Optional decorator event for customizing code generation behavior.
-     *
-     * Provides additional metadata or instructions that can modify how the
-     * function implementation is generated. Can include custom annotations,
-     * middleware configurations, or special handling directives that affect the
-     * final code output.
-     */
-    decoratorEvent?: AutoBeRealizeAuthorization;
-}
 /**
  * Generates a planning result that defines what kind of function should be
  * created, based solely on the provided Swagger (OpenAPI) operation — without

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

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

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

@@ -1,4 +1,4 @@
-import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import { AutoBeOpenApi, AutoBeRealizeAuthorization, AutoBeTestFile } from "@autobe/interface";
 export declare namespace IAutoBeRealizeScenarioApplication {
     interface IProps {
         /** The OpenAPI operation to be realized. */
@@ -24,7 +24,7 @@ export declare namespace IAutoBeRealizeScenarioApplication {
          * certain conditions. Used as a basis for TDD-style automated test
          * generation.
          */
-        testScenarios: string[];
+        testFiles: AutoBeTestFile[];
         /**
          * Optional decorator event for customizing code generation behavior.
          *

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

@@ -17,13 +17,16 @@ export declare namespace IAutoBeRealizeWriteApplication {
          * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION:
          *
          * DO:
+         *
          * - 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
          *
          * DO NOT:
+         *
          * - Assume common fields exist without verification
-         * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active without checking
+         * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active
+         *   without checking
          *
          * 📋 STEP 2 - FIELD INVENTORY:
          *
@@ -171,10 +174,12 @@ export declare namespace IAutoBeRealizeWriteApplication {
          * Import rules:
          *
          * DO NOT:
+         *
          * - Add any new import statements manually
          * - Write import statements directly (this causes compile errors)
          *
-         * Note: All necessary imports are provided globally or by the system automatically.
+         * Note: All necessary imports are provided globally or by the system
+         * automatically.
          *
          * ✅ Requirements:
          *

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

@@ -1,4 +1,6 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 import { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
-export declare const transformTestCorrectHistories: (func: IAutoBeTestFunction, failure: IAutoBeTypeScriptCompileResult.IFailure) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;
+export declare const transformTestCorrectHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, func: IAutoBeTestFunction, failure: IAutoBeTypeScriptCompileResult.IFailure) => Promise<Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>>;

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

@@ -1,7 +1,9 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeTestScenario } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
-export declare function transformTestWriteHistories(scenario: AutoBeTestScenario, artifacts: IAutoBeTestScenarioArtifacts): Array<IAgenticaHistoryJson.ISystemMessage>;
+export declare function transformTestWriteHistories<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeTestScenario, artifacts: IAutoBeTestScenarioArtifacts): Promise<Array<IAgenticaHistoryJson.ISystemMessage | IAgenticaHistoryJson.IAssistantMessage>>;
 export declare namespace transformTestWriteHistories {
     function structures(artifacts: IAutoBeTestScenarioArtifacts): string;
     function functional(artifacts: IAutoBeTestScenarioArtifacts): string;

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

@@ -67,8 +67,8 @@ export declare namespace IAutoBeTestCorrectApplication {
          * AI generates the first corrected version of the test code based on error
          * analysis and correction strategies. This draft addresses all identified
          * compilation errors while preserving the original business logic and test
-         * workflow. The code is compilation-error-free and follows all
-         * established conventions.
+         * workflow. The code is compilation-error-free and follows all established
+         * conventions.
          *
          * The implementation incorporates lessons learned from error analysis to
          * produce properly typed, syntactically correct code that maintains the

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

@@ -28,6 +28,18 @@ export declare namespace IAutoBeTestScenarioApplication {
          *
          * Each scenario represents a specific test case for the same `path` and
          * `method`.
+         *
+         * IMPORTANT: Each scenario must be actually implementable. A scenario's
+         * implementability is determined by the existence of ALL APIs (endpoints)
+         * required to test it. This includes not only the primary endpoint being
+         * tested, but also ALL dependency endpoints needed for setup,
+         * authentication, and data preparation. If even one required dependency API
+         * is missing from the available operations, the scenario cannot be
+         * implemented and should not be generated.
+         *
+         * Example: A "test banned user login" scenario requires both a login API
+         * AND a ban user API. If the ban API doesn't exist, this scenario is not
+         * implementable regardless of database schema fields.
          */
         scenarios: IScenario[] & tags.MinItems<1>;
     }
@@ -37,6 +49,11 @@ export declare namespace IAutoBeTestScenarioApplication {
      * This interface defines a structured, user-centric test draft that includes
      * a descriptive function name, a detailed scenario draft, and logical
      * dependencies on other endpoints required for context or setup.
+     *
+     * CRITICAL: All referenced endpoints MUST exist in the provided API
+     * operations. Do NOT create scenarios for non-existent APIs, even if database
+     * schema fields suggest their existence. Test scenarios must be implementable
+     * with available APIs only.
      */
     interface IScenario {
         /**
@@ -113,11 +130,21 @@ export declare namespace IAutoBeTestScenarioApplication {
          * authentication, resource creation, or data setup, that are relevant to
          * the test. This list is not a strict execution order — if ordering is
          * important, it must be described explicitly in the `purpose`.
+         *
+         * WARNING: Every endpoint referenced here MUST exist in the provided API
+         * operations. Do NOT reference endpoints that are not explicitly available,
+         * even if they seem logically necessary based on database schema or
+         * business logic.
          */
         dependencies: IDependencies[];
     }
     interface IDependencies {
-        /** Target API endpoint that this scenario depends on. */
+        /**
+         * Target API endpoint that this scenario depends on.
+         *
+         * This endpoint MUST exist in the available API operations list.
+         * Non-existent endpoints will cause test implementation failures.
+         */
         endpoint: AutoBeOpenApi.IEndpoint;
         /**
          * A concise explanation of why this API call is relevant or required for

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

@@ -32,8 +32,8 @@ export declare namespace IAutoBeTestWriteApplication {
          *
          * AI determines the appropriate domain category based on the scenario
          * analysis. This classification drives file structure, test categorization,
-         * and logical grouping. The domain must be a single, lowercase word that
-         * represents the primary API resource.
+         * and logical grouping. The domain must be a single, lowercase word in
+         * snake_case format that represents the primary API resource.
          *
          * Workflow: Scenario analysis → Domain identification → Test organization
          * structure

package/lib/utils/executeCachedBatch.d.ts

@@ -0,0 +1 @@
+export declare const executeCachedBatch: <T>(tasks: Array<(user: string) => Promise<T>>, promptCacheKey?: string) => Promise<T[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobe/agent",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "description": "AI backend server code generator",
   "main": "lib/index.js",
   "author": "Wrtn Technologies",
@@ -20,15 +20,15 @@
     "README.md"
   ],
   "dependencies": {
-    "@agentica/core": "^0.32.1",
+    "@agentica/core": "0.32.3-dev.3",
     "@prisma/internals": "^6.7.0",
     "@samchon/openapi": "^4.7.1",
     "openai": "^5.12.2",
     "tstl": "^3.0.0",
-    "typia": "^9.7.1",
+    "typia": "^9.7.2",
     "uuid": "^11.1.0",
-    "@autobe/interface": "^0.19.1",
-    "@autobe/utils": "^0.19.1"
+    "@autobe/utils": "^0.21.0",
+    "@autobe/interface": "^0.21.0"
   },
   "devDependencies": {
     "@rollup/plugin-json": "^6.1.0",
@@ -40,8 +40,8 @@
     "ts-node": "^10.9.2",
     "ts-patch": "^3.3.0",
     "typescript": "~5.9.2",
-    "@autobe/filesystem": "^0.19.1",
-    "@autobe/compiler": "^0.19.1"
+    "@autobe/filesystem": "^0.21.0",
+    "@autobe/compiler": "^0.21.0"
   },
   "keywords": [
     "ai",

package/src/AutoBeAgent.ts

@@ -13,7 +13,7 @@ import {
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { Semaphore, Singleton } from "tstl";
-import { v4 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeAgentBase } from "./AutoBeAgentBase";
 import { AutoBeContext } from "./context/AutoBeContext";
@@ -202,7 +202,7 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
     this.agentica_.on("assistantMessage", async (message) => {
       const start = new Date();
       const history: AutoBeAssistantMessageHistory = {
-        id: v4(),
+        id: v7(),
         type: "assistantMessage",
         text: await message.join(),
         created_at: start.toISOString(),
@@ -212,6 +212,7 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
       this.histories_.push(history);
       this.dispatch({
         type: "assistantMessage",
+        id: history.id,
         text: history.text,
         created_at: history.created_at,
       }).catch(() => {});
@@ -253,7 +254,7 @@ export class AutoBeAgent<Model extends ILlmSchema.Model>
   ): Promise<AutoBeHistory[]> {
     const index: number = this.histories_.length;
     const userMessageHistory: AutoBeUserMessageHistory = {
-      id: v4(),
+      id: v7(),
       type: "userMessage",
       contents:
         typeof content === "string"

package/src/AutoBeMockAgent.ts

@@ -11,7 +11,7 @@ import {
   IAutoBePlaygroundReplay,
 } from "@autobe/interface";
 import { Singleton, randint, sleep_for } from "tstl";
-import { v4 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeAgentBase } from "./AutoBeAgentBase";
 import { AutoBeState } from "./context/AutoBeState";
@@ -50,7 +50,7 @@ export class AutoBeMockAgent extends AutoBeAgentBase implements IAutoBeAgent {
   ): Promise<AutoBeHistory[]> {
     // THE USER-MESSAGE
     const userMessage: AutoBeUserMessageHistory = {
-      id: v4(),
+      id: v7(),
       type: "userMessage",
       contents:
         typeof content === "string"
@@ -72,7 +72,7 @@ export class AutoBeMockAgent extends AutoBeAgentBase implements IAutoBeAgent {
     if (state.realize !== null) {
       await sleep_for(2_000);
       const assistantMessage: AutoBeAssistantMessageHistory = {
-        id: v4(),
+        id: v7(),
         type: "assistantMessage",
         text: [
           "AutoBE has successfully realized the application.",
@@ -94,7 +94,7 @@ export class AutoBeMockAgent extends AutoBeAgentBase implements IAutoBeAgent {
       if (snapshots === null) {
         this.histories_.push(userMessage);
         this.histories_.push({
-          id: v4(),
+          id: v7(),
           type: "assistantMessage",
           text: [
             "The histories are prepared until current state.",
@@ -175,6 +175,7 @@ const sleepMap: Record<AutoBeEvent.Type, number> = {
   interfaceStart: 1_000,
   interfaceGroups: 1_000,
   interfaceEndpoints: 1_000,
+  interfaceEndpointsReview: 1_000,
   interfaceOperations: 400,
   interfaceOperationsReview: 400,
   interfaceAuthorization: 400,