@autobe/agent 0.16.1 → 0.17.1

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

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

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

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

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

@@ -0,0 +1,214 @@
+import { AutoBePrisma } from "@autobe/interface";
+
+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 {
+    /**
+     * Step 1: 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
+     */
+    thinking: string;
+
+    /**
+     * Step 2: Initial Prisma schema code implementation.
+     *
+     * AI generates the first working version of the Prisma schema based on the
+     * strategic plan. This draft must be syntactically correct Prisma Schema
+     * Language (PSL) code that implements all planned tables, relationships,
+     * and constraints. The schema should follow Prisma conventions while
+     * incorporating enterprise patterns like snapshot tables and materialized
+     * views.
+     *
+     * **Implementation Requirements:**
+     *
+     * - **Exact Table Names**: Use EXACT names from targetComponent.tables (NO
+     *   CHANGES)
+     * - **Valid PSL Syntax**: Proper model blocks, field definitions, and
+     *   directives
+     * - **Primary Keys**: Always UUID type with `@id` directive
+     * - **Foreign Keys**: UUID type following {target_model}_id naming pattern
+     * - **Data Types**: uuid, string, int, double, datetime, boolean, uri (no
+     *   pre-calculated fields)
+     * - **Relationships**: Proper `@relation` directives for 1:1, 1:N, M:N
+     *   patterns
+     * - **Descriptions**: Follow format with requirements mapping and business
+     *   purpose
+     * - **NO Prohibited Fields**: No totals, cached values, aggregates in regular
+     *   tables
+     *
+     * Workflow: Strategic plan → PSL implementation → Functional schema code
+     */
+    draft: string;
+
+    /**
+     * Step 3: Schema code review and quality assessment.
+     *
+     * AI performs a thorough review of the draft schema implementation,
+     * examining multiple quality dimensions to ensure production readiness.
+     * This review process identifies issues, suggests improvements, and
+     * validates compliance with best practices.
+     *
+     * **Review Dimensions:**
+     *
+     * **Syntax & Compilation:**
+     *
+     * - Prisma schema syntax errors and invalid directives
+     * - Model naming matches targetComponent.tables EXACTLY
+     * - Field type appropriateness (uuid for keys, no calculated fields)
+     * - Relationship definition correctness (`@relation` syntax)
+     *
+     * **Database Design Quality:**
+     *
+     * - **Normalization Compliance**:
+     *
+     *   - 1NF: Atomic values, no repeating groups
+     *   - 2NF: No partial dependencies on composite keys
+     *   - 3NF: No transitive dependencies
+     * - **Prohibited Fields Check**: No pre-calculated totals, cached values, or
+     *   aggregates in regular tables
+     * - **Snapshot Pattern**: Proper implementation for audit trails
+     * - **Junction Tables**: Correct naming ({table1}_{table2}) and structure
+     *
+     * **Index Strategy Validation:**
+     *
+     * - NO single foreign key indexes (Prisma auto-creates these)
+     * - Composite indexes for query patterns
+     * - Unique indexes for business constraints
+     * - GIN indexes for full-text search fields
+     *
+     * **Description Quality:**
+     *
+     * - Models include: requirement mapping, business purpose, relationships,
+     *   behaviors
+     * - Fields include: requirement aspect, business meaning, normalization
+     *   rationale
+     *
+     * Workflow: Draft schema → Systematic analysis → Specific improvements
+     */
+    review: string;
+
+    /**
+     * Step 4: Final production-ready Prisma schema code.
+     *
+     * AI produces the final, polished version of the Prisma schema
+     * incorporating all review feedback. This code represents the completed
+     * schema implementation, ready for database migration and production
+     * deployment. All identified issues must be resolved, and the schema must
+     * meet enterprise-grade quality standards.
+     *
+     * **Final Schema Characteristics:**
+     *
+     * - **Complete Coverage**: All targetComponent.tables implemented with exact
+     *   names
+     * - **Zero Errors**: Valid PSL syntax, no compilation warnings
+     * - **Proper Relationships**: All foreign keys reference existing tables
+     *   correctly
+     * - **Optimized Indexes**: Strategic indexes without redundant foreign key
+     *   indexes
+     * - **Full Normalization**: Strict 3NF compliance, denormalization only in
+     *   mv_ tables
+     * - **Enterprise Documentation**: Complete descriptions with business context
+     * - **Audit Support**: Proper snapshot patterns and temporal fields
+     *   (created_at, updated_at, deleted_at)
+     * - **Type Safety**: Consistent use of UUID for all keys, appropriate field
+     *   types
+     *
+     * Workflow: Review feedback → Schema refinement → Production-ready PSL code
+     */
+    final: string;
+
+    /**
+     * Step 5: Structured AST representation of the Prisma schema models.
+     *
+     * AI transforms the final Prisma schema code into a structured Abstract
+     * Syntax Tree (AST) representation using the AutoBePrisma.IModel interface.
+     * This involves critical reinterpretation and reclassification of the final
+     * code to conform to AST constraints.
+     *
+     * **CRITICAL: Reinterpretation & Post-Processing Required**
+     *
+     * The AI-generated final code may not directly map to valid AST structures
+     * due to:
+     *
+     * - Complex Prisma directives that need decomposition
+     * - Field attributes that require reclassification
+     * - Implicit relationships that need explicit AST representation
+     * - Schema-level constructs that must be distributed to models
+     *
+     * **Required Post-Processing Steps:**
+     *
+     * 1. **Field Reclassification**: Separate fields into primary, foreign, and
+     *    plain categories
+     * 2. **Relationship Extraction**: Convert `@relation` directives to IRelation
+     *    structures
+     * 3. **Index Decomposition**: Parse `@@index`, `@@unique` into appropriate
+     *    index arrays
+     * 4. **Type Normalization**: Map Prisma types to AST type enum values
+     * 5. **Constraint Resolution**: Convert schema constraints to AST properties
+     *
+     * **AST Structure Requirements:**
+     *
+     * - **Model Array**: Each table from targetComponent.tables as IModel
+     * - **Primary Field**: Always UUID type with name "id"
+     * - **Foreign Fields**: Proper IRelation configurations for all relationships
+     * - **Plain Fields**: Business fields with correct types (no calculated
+     *   fields)
+     * - **Indexes**:
+     *
+     *   - UniqueIndexes: Business constraints and composite unique keys
+     *   - PlainIndexes: Query optimization (no single foreign key indexes)
+     *   - GinIndexes: Full-text search on string fields
+     * - **Material Flag**: true only for mv_ prefixed tables
+     *
+     * **Relationship Patterns in AST:**
+     *
+     * - 1:1: Foreign field with unique: true
+     * - 1:N: Foreign field with unique: false
+     * - M:N: Separate junction table model with composite indexes
+     *
+     * Workflow: Final PSL code → Reinterpretation → AST transformation →
+     * Structured models
+     *
+     * This structured representation serves as the ultimate deliverable for
+     * programmatic schema generation and manipulation.
+     */
+    models: AutoBePrisma.IModel[];
+  }
+}

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -7,11 +7,11 @@ import {
   IAutoBeCompiler,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
-import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
 import { getAutoBeGenerated } from "../../factory/getAutoBeGenerated";
+import { getAutoBeRealizeGenerated } from "../../factory/getAutoBeRealizeGenerated";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { writeCodeUntilCompilePassed } from "./writeCodeUntilCompilePassed";
 
@@ -26,7 +26,6 @@ export const orchestrateRealize =
       throw new Error("Can't do realize agent because operations are nothing.");
     }
 
-    const start: Date = new Date();
     ctx.dispatch({
       type: "realizeStart",
       created_at: new Date().toISOString(),
@@ -54,41 +53,29 @@ export const orchestrateRealize =
         authorizations,
       });
 
-    const history: AutoBeRealizeHistory = {
-      type: "realize",
-      compiled: result.compiled,
-      authorizations,
-      functions,
-      controllers,
-      completed_at: new Date().toISOString(),
-      created_at: start.toISOString(),
-      id: v4(),
-      reason: props.reason,
-      step: ctx.state().analyze?.step ?? 0,
-    };
-
     // report
-    ctx.dispatch({
+    return ctx.dispatch({
       type: "realizeComplete",
       created_at: new Date().toISOString(),
-      functions: history.functions,
-      authorizations: history.authorizations,
-      controllers: history.controllers,
+      functions,
+      authorizations,
+      controllers,
       compiled: await compiler.typescript.compile({
-        files: await getAutoBeGenerated(
-          compiler,
-          {
-            ...ctx.state(),
-            realize: history,
-          },
-          [...ctx.histories(), history],
-          ctx.usage(),
-        ),
+        files: {
+          ...(await getAutoBeGenerated(
+            compiler,
+            ctx.state(),
+            ctx.histories(),
+            ctx.usage(),
+          )),
+          ...(await getAutoBeRealizeGenerated({
+            document: ctx.state().interface!.document,
+            authorizations,
+            functions,
+            compiler,
+          })),
+        },
       }),
       step: ctx.state().analyze?.step ?? 0,
     });
-    ctx.state().realize = history;
-    ctx.histories().push(history);
-
-    return history;
   };

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -95,7 +95,7 @@ async function process<Model extends ILlmSchema.Model>(
   await agentica
     .conversate("Create Authorization Provider and Decorator.")
     .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
+      const tokenUsage = agentica.getTokenUsage().aggregate;
       ctx.usage().record(tokenUsage, ["realize"]);
     });
   if (pointer.value === null) throw new Error("Failed to create decorator.");

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -105,7 +105,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
   await agentica
     .conversate("Please correct the decorator and the provider.")
     .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
+      const tokenUsage = agentica.getTokenUsage().aggregate;
       ctx.usage().record(tokenUsage, ["realize"]);
     });
 

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -114,7 +114,7 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
       ].join("\n"),
     ),
   ).finally(() => {
-    const tokenUsage = agent.getTokenUsage();
+    const tokenUsage = agent.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["realize"]);
   });
 

package/src/orchestrate/test/orchestrateTest.ts

@@ -1,7 +1,6 @@
 import {
   AutoBeAssistantMessageHistory,
   AutoBeOpenApi,
-  AutoBeTestFile,
   AutoBeTestHistory,
   AutoBeTestScenarioEvent,
   AutoBeTestValidateEvent,
@@ -33,8 +32,8 @@ export const orchestrateTest =
 
     const operations: AutoBeOpenApi.IOperation[] =
       ctx.state().interface?.document.operations ?? [];
-    if (operations.length === 0) {
-      const history: AutoBeAssistantMessageHistory = {
+    if (operations.length === 0)
+      return ctx.assistantMessage({
         id: v4(),
         type: "assistantMessage",
         created_at: start.toISOString(),
@@ -42,11 +41,7 @@ export const orchestrateTest =
         text:
           "Unable to write test code because there are no Operations, " +
           "please check if the Interface agent is called.",
-      };
-      ctx.histories().push(history);
-      ctx.dispatch(history);
-      return history;
-    }
+      });
 
     // PLAN
     const scenarioEvent: AutoBeTestScenarioEvent =
@@ -69,7 +64,6 @@ export const orchestrateTest =
 
     // DO COMPILE
     const compiler: IAutoBeCompiler = await ctx.compiler();
-    const result: AutoBeTestFile[] = success.map((c) => c.file);
     const compiled: IAutoBeTypeScriptCompileResult =
       await compiler.typescript.compile({
         files: Object.fromEntries([
@@ -78,28 +72,14 @@ export const orchestrateTest =
               dbms: "sqlite",
             }),
           ).filter(([key]) => key.endsWith(".ts")),
-          ...result.map((f) => [f.location, f.content]),
+          ...success.map((s) => [s.file.location, s.file.content]),
         ]),
       });
-
-    const history: AutoBeTestHistory = {
-      type: "test",
-      id: v4(),
-      completed_at: new Date().toISOString(),
-      created_at: start.toISOString(),
-      files: result,
-      compiled,
-      reason: "Step to the test generation referencing the interface",
-      step: ctx.state().interface?.step ?? 0,
-    };
-    ctx.dispatch({
+    return ctx.dispatch({
       type: "testComplete",
       created_at: start.toISOString(),
-      files: result,
+      files: success.map((s) => s.file),
       compiled,
       step: ctx.state().interface?.step ?? 0,
     });
-    ctx.state().test = history;
-    ctx.histories().push(history);
-    return history;
   };

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -131,7 +131,7 @@ const correct = async <Model extends ILlmSchema.Model>(
       "Fix the `AutoBeTest.IFunction` data to resolve the compilation error.",
     )
     .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
+      const tokenUsage = agentica.getTokenUsage().aggregate;
       ctx.usage().record(tokenUsage, ["test"]);
     });
   if (pointer.value === null) throw new Error("Failed to modify test code.");

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -146,7 +146,7 @@ const execute = async <Model extends ILlmSchema.Model>(
   enforceToolCall(agentica);
 
   await agentica.conversate(`create test scenarios.`).finally(() => {
-    const tokenUsage = agentica.getTokenUsage();
+    const tokenUsage = agentica.getTokenUsage().aggregate;
     ctx.usage().record(tokenUsage, ["test"]);
   });
   if (pointer.value.length === 0) {