@autobe/agent 0.21.0 → 0.22.0

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -17,13 +17,13 @@ import { completeTestCode } from "./compile/completeTestCode";
 import { transformTestCorrectHistories } from "./histories/transformTestCorrectHistories";
 import { IAutoBeTestCorrectApplication } from "./structures/IAutoBeTestCorrectApplication";
 import { IAutoBeTestFunction } from "./structures/IAutoBeTestFunction";
+import { IAutoBeTestFunctionFailure } from "./structures/IAutoBeTestFunctionFailure";
 import { IAutoBeTestScenarioArtifacts } from "./structures/IAutoBeTestScenarioArtifacts";
 import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
 
 export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   writeResult: IAutoBeTestWriteResult[],
-  life: number = 4,
 ): Promise<AutoBeTestValidateEvent[]> => {
   const result: Array<AutoBeTestValidateEvent | null> =
     await executeCachedBatch(
@@ -33,7 +33,7 @@ export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
             artifacts: w.artifacts,
             scenario: w.scenario,
             location: w.event.location,
-            script: w.event.final,
+            script: w.event.final ?? w.event.draft,
           });
           return await predicate(
             ctx,
@@ -41,10 +41,11 @@ export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
               artifacts: w.artifacts,
               scenario: w.scenario,
               location: w.event.location,
-              script: w.event.final,
+              script: w.event.final ?? w.event.draft,
             },
+            [],
             event,
-            life,
+            ctx.retry,
           );
         } catch {
           return null;
@@ -83,18 +84,20 @@ const compile = async <Model extends ILlmSchema.Model>(
 const predicate = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   content: IAutoBeTestFunction,
+  failures: IAutoBeTestFunctionFailure[],
   event: AutoBeTestValidateEvent,
   life: number,
 ): Promise<AutoBeTestValidateEvent> => {
   if (event.result.type === "failure") ctx.dispatch(event);
   return event.result.type === "failure"
-    ? await correct(ctx, content, event, life - 1)
+    ? await correct(ctx, content, failures, event, life - 1)
     : event;
 };
 
 const correct = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   content: IAutoBeTestFunction,
+  failures: IAutoBeTestFunctionFailure[],
   validate: AutoBeTestValidateEvent,
   life: number,
 ): Promise<AutoBeTestValidateEvent> => {
@@ -106,11 +109,13 @@ const correct = async <Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "testCorrect",
-    histories: await transformTestCorrectHistories(
-      ctx,
-      content,
-      validate.result,
-    ),
+    histories: await transformTestCorrectHistories(ctx, content, [
+      ...failures,
+      {
+        function: content,
+        failure: validate.result,
+      },
+    ]),
     controller: createController({
       model: ctx.model,
       artifacts: content.artifacts,
@@ -129,7 +134,14 @@ const correct = async <Model extends ILlmSchema.Model>(
   if (pointer.value === null) throw new Error("Failed to modify test code.");
 
   const compiler: IAutoBeCompiler = await ctx.compiler();
-  pointer.value.final = await compiler.typescript.beautify(pointer.value.final);
+  if (pointer.value.revise)
+    pointer.value.revise.final = await compiler.typescript.beautify(
+      pointer.value.revise.final,
+    );
+  else
+    pointer.value.draft = await compiler.typescript.beautify(
+      pointer.value.draft,
+    );
 
   ctx.dispatch({
     type: "testCorrect",
@@ -139,14 +151,29 @@ const correct = async <Model extends ILlmSchema.Model>(
     result: validate.result,
     tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
-    ...pointer.value,
+    think: pointer.value.think,
+    draft: pointer.value.draft,
+    review: pointer.value.revise?.review,
+    final: pointer.value.revise?.final,
   });
   const newContent: IAutoBeTestFunction = {
     ...content,
-    script: pointer.value.final,
+    script: pointer.value.revise?.final ?? pointer.value.draft,
   };
   const newValidate: AutoBeTestValidateEvent = await compile(ctx, newContent);
-  return predicate(ctx, newContent, newValidate, life);
+  return predicate(
+    ctx,
+    newContent,
+    [
+      ...failures,
+      {
+        function: content,
+        failure: validate.result,
+      },
+    ],
+    newValidate,
+    life,
+  );
 };
 
 const createController = <Model extends ILlmSchema.Model>(props: {
@@ -166,7 +193,11 @@ const createController = <Model extends ILlmSchema.Model>(props: {
     execute: {
       rewrite: (next) => {
         next.draft = completeTestCode(props.artifacts, next.draft);
-        next.final = completeTestCode(props.artifacts, next.final);
+        if (next.revise)
+          next.revise.final = completeTestCode(
+            props.artifacts,
+            next.revise.final,
+          );
         props.build(next);
       },
     } satisfies IAutoBeTestCorrectApplication,

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -64,7 +64,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
   do {
     const matrix: AutoBeOpenApi.IOperation[][] = divideArray({
       array: include,
-      capacity: 5,
+      capacity: 4,
     });
     await executeCachedBatch(
       matrix.map((include) => async (promptCacheKey) => {
@@ -121,56 +121,60 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
   const pointer: IPointer<IAutoBeTestScenarioApplication.IScenarioGroup[]> = {
     value: [],
   };
-
   const authorizations: AutoBeInterfaceAuthorization[] =
     ctx.state().interface?.authorizations ?? [];
 
-  const { tokenUsage } = await ctx.conversate({
-    source: "testScenarios",
-    histories: transformTestScenarioHistories(
-      ctx.state(),
-      props.entire,
-      props.include,
-      props.exclude,
-    ),
-    controller: createController({
-      model: ctx.model,
-      endpointNotFound: props.endpointNotFound,
-      dict: props.dict,
-      authorizations,
-      build: (next) => {
-        pointer.value ??= [];
-        pointer.value.push(...next.scenarioGroups);
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: `Create e2e test scenarios.`,
-  });
-  if (pointer.value.length === 0) return [];
-  ctx.dispatch({
-    type: "testScenarios",
-    id: v7(),
-    tokenUsage,
-    scenarios: pointer.value
-      .map((v) =>
-        v.scenarios.map(
-          (s) =>
-            ({
-              endpoint: v.endpoint,
-              draft: s.draft,
-              functionName: s.functionName,
-              dependencies: s.dependencies,
-            }) satisfies AutoBeTestScenario,
-        ),
-      )
-      .flat(),
-    completed: ++props.progress.completed,
-    total: props.progress.total,
-    step: ctx.state().interface?.step ?? 0,
-    created_at: new Date().toISOString(),
-  });
-  return pointer.value;
+  try {
+    const { tokenUsage } = await ctx.conversate({
+      source: "testScenarios",
+      histories: transformTestScenarioHistories(
+        ctx.state(),
+        props.entire,
+        props.include,
+        props.exclude,
+      ),
+      controller: createController({
+        model: ctx.model,
+        endpointNotFound: props.endpointNotFound,
+        dict: props.dict,
+        authorizations,
+        build: (next) => {
+          pointer.value ??= [];
+          pointer.value.push(...next.scenarioGroups);
+        },
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      message: `Create e2e test scenarios.`,
+    });
+    if (pointer.value.length === 0) return [];
+    ctx.dispatch({
+      type: "testScenarios",
+      id: v7(),
+      tokenUsage,
+      scenarios: pointer.value
+        .map((v) =>
+          v.scenarios.map(
+            (s) =>
+              ({
+                endpoint: v.endpoint,
+                draft: s.draft,
+                functionName: s.functionName,
+                dependencies: s.dependencies,
+              }) satisfies AutoBeTestScenario,
+          ),
+        )
+        .flat(),
+      completed: (props.progress.completed += pointer.value.length),
+      total: props.progress.total,
+      step: ctx.state().interface?.step ?? 0,
+      created_at: new Date().toISOString(),
+    });
+    return pointer.value;
+  } catch {
+    console.log("test scenario, failed to function call", props.include);
+    return [];
+  }
 };
 
 function createController<Model extends ILlmSchema.Model>(props: {

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -50,7 +50,7 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
           artifacts,
           event,
         };
-      } catch {
+      } catch (error) {
         return null;
       }
     }),
@@ -85,16 +85,30 @@ async function process<Model extends ILlmSchema.Model>(
     promptCacheKey,
     message: "Create e2e test functions.",
   });
-  if (pointer.value === null) throw new Error("Failed to create test code.");
+  if (pointer.value === null) {
+    ++progress.completed;
+    throw new Error("Failed to create test code.");
+  }
 
   const compiler: IAutoBeCompiler = await ctx.compiler();
-  pointer.value.final = await compiler.typescript.beautify(pointer.value.final);
+  if (pointer.value.revise)
+    pointer.value.revise.final = await compiler.typescript.beautify(
+      pointer.value.revise.final,
+    );
+  else
+    pointer.value.draft = await compiler.typescript.beautify(
+      pointer.value.draft,
+    );
   return {
     type: "testWrite",
     id: v7(),
     created_at: new Date().toISOString(),
     location: `test/features/api/${pointer.value.domain}/${scenario.functionName}.ts`,
-    ...pointer.value,
+    scenario: pointer.value.scenario,
+    domain: pointer.value.domain,
+    draft: pointer.value.draft,
+    review: pointer.value.revise?.review,
+    final: pointer.value.revise?.final,
     tokenUsage,
     completed: ++progress.completed,
     total: progress.total,
@@ -119,7 +133,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
     execute: {
       write: (next) => {
         next.draft = completeTestCode(props.artifacts, next.draft);
-        next.final = completeTestCode(props.artifacts, next.final);
+        if (next.revise)
+          next.revise.final = completeTestCode(
+            props.artifacts,
+            next.revise.final,
+          );
         props.build(next);
       },
     } satisfies IAutoBeTestWriteApplication,

package/src/orchestrate/test/structures/IAutoBeTestCorrectApplication.ts

@@ -4,16 +4,14 @@ export interface IAutoBeTestCorrectApplication {
    * generates corrected E2E test code.
    *
    * The AI executes this function to perform the complete error correction
-   * workflow: error-free analysis → compilation error analysis → draft
-   * correction → code review → final corrected implementation. This multi-step
-   * process ensures systematic error resolution while preserving original test
-   * functionality and maintaining code quality.
+   * workflow: compilation error analysis → draft correction → code review →
+   * final corrected implementation. This multi-step process ensures systematic
+   * error resolution while preserving original test functionality and
+   * maintaining code quality.
    *
-   * The corrector first analyzes the scenario without considering compilation
-   * errors to understand the intended functionality, then incorporates
-   * compilation diagnostics to identify specific issues, and finally produces
-   * corrected code through iterative refinement with comprehensive review and
-   * validation.
+   * The corrector analyzes compilation diagnostics to identify specific issues,
+   * develops correction strategies, and produces corrected code through
+   * iterative refinement with comprehensive review and validation.
    *
    * @param props Complete specification for error correction workflow including
    *   analysis steps, draft implementation, review process, and final code
@@ -25,47 +23,30 @@ export interface IAutoBeTestCorrectApplication {
 export namespace IAutoBeTestCorrectApplication {
   export interface IProps {
     /**
-     * Step 1: Initial analysis and understanding without compilation error
-     * context.
-     *
-     * AI analyzes the original test scenario, business requirements, and
-     * intended functionality without being influenced by compilation errors.
-     * This clean analysis establishes a clear understanding of what the test
-     * accomplishes, the expected business workflow, and the correct API
-     * integration patterns.
-     *
-     * This step ensures that error correction doesn't lose sight of the
-     * original test purpose and helps maintain the intended business logic
-     * while addressing technical compilation issues. The AI develops a
-     * comprehensive understanding of the test requirements before diving into
-     * error-specific details.
-     *
-     * Workflow: Scenario understanding → Business logic analysis → Intended
-     * functionality mapping
-     */
-    think_without_compile_error: string;
-
-    /**
-     * Step 2: Compilation error analysis and root cause identification.
+     * Step 1: Deep compilation error analysis and correction strategy.
+     *
+     * AI performs comprehensive analysis of compilation errors to develop
+     * targeted correction strategies. This step involves deep examination of
+     * error messages, identification of error patterns, understanding root
+     * causes, and planning systematic corrections.
      *
-     * AI re-analyzes the scenario and implementation with full awareness of
-     * compilation errors and diagnostic information. This step involves
-     * systematic examination of error messages, identification of error
-     * patterns, and understanding of how compilation issues relate to the
-     * intended functionality.
+     * The AI examines each compilation diagnostic to understand where the
+     * implementation diverged from correct TypeScript usage, identifies the
+     * business logic intent behind the failed code, and formulates strategies
+     * to fix errors while preserving the original test purpose. This analysis
+     * correlates error patterns with code structure to ensure corrections
+     * address root causes rather than symptoms.
      *
-     * The AI correlates compilation diagnostics with the original requirements
-     * to understand where the implementation diverged from correct TypeScript
-     * usage while maintaining the business logic intent. This analysis forms
-     * the foundation for targeted error correction strategies.
+     * This deep analysis forms the foundation for all subsequent correction
+     * efforts, ensuring a methodical approach to resolving compilation issues.
      *
      * Workflow: Error diagnostic analysis → Root cause identification →
-     * Correction strategy planning
+     * Correction strategy planning → Business logic preservation strategy
      */
-    think_again_with_compile_error: string;
+    think: string;
 
     /**
-     * Step 3: Draft corrected TypeScript E2E test code implementation.
+     * Step 2: Draft corrected TypeScript E2E test code implementation.
      *
      * AI generates the first corrected version of the test code based on error
      * analysis and correction strategies. This draft addresses all identified
@@ -86,7 +67,29 @@ export namespace IAutoBeTestCorrectApplication {
     draft: string;
 
     /**
-     * Step 4: Code review and correction validation.
+     * Step 3-4: Review and finalization process.
+     *
+     * Encapsulates the review and final implementation phases into a single
+     * revision process. This structured approach ensures systematic validation
+     * and refinement of the corrected code through comprehensive review
+     * followed by production-ready implementation.
+     *
+     * The revision process maintains clear separation between review feedback
+     * and final deliverable while ensuring all corrections are properly
+     * validated and integrated.
+     */
+    revise: IReviseProps;
+  }
+
+  /**
+   * Revision properties for the final review and implementation phases.
+   *
+   * This interface encapsulates the final two steps of the error correction
+   * workflow, ensuring systematic review and production-ready code delivery.
+   */
+  export interface IReviseProps {
+    /**
+     * Step 3: Code review and correction validation.
      *
      * AI performs a comprehensive review of the corrected draft implementation,
      * validating that all compilation errors have been resolved and that the
@@ -105,7 +108,7 @@ export namespace IAutoBeTestCorrectApplication {
     review: string;
 
     /**
-     * Step 5: Final production-ready corrected test code.
+     * Step 4: Final production-ready corrected test code.
      *
      * AI produces the final, polished version of the corrected test code
      * incorporating all review feedback and validation results. This code
@@ -119,7 +122,7 @@ export namespace IAutoBeTestCorrectApplication {
      * behaviors and user workflows.
      *
      * Workflow: Review integration → Final refinement → Production-ready
-     * implementation This is the ultimate deliverable that will replace the
+     * implementation. This is the ultimate deliverable that will replace the
      * compilation-failed code.
      */
     final: string;

package/src/orchestrate/test/structures/IAutoBeTestFunctionFailure.ts

@@ -0,0 +1,8 @@
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+
+import { IAutoBeTestFunction } from "./IAutoBeTestFunction";
+
+export interface IAutoBeTestFunctionFailure {
+  function: IAutoBeTestFunction;
+  failure: IAutoBeTypeScriptCompileResult.IFailure;
+}

package/src/orchestrate/test/structures/IAutoBeTestScenarioArtifacts.ts

@@ -5,4 +5,5 @@ export interface IAutoBeTestScenarioArtifacts {
   sdk: Record<string, string>;
   dto: Record<string, string>;
   e2e: Record<string, string>;
+  template: string;
 }

package/src/orchestrate/test/structures/IAutoBeTestWriteApplication.ts

@@ -60,6 +60,20 @@ export namespace IAutoBeTestWriteApplication {
      */
     draft: string;
 
+    /**
+     * Steps 4-5: Code review and final refinement process.
+     *
+     * Contains the iterative improvement workflow that transforms the initial
+     * draft into production-ready test code. This two-phase process ensures
+     * systematic quality enhancement through comprehensive review followed by
+     * targeted refinement based on identified issues.
+     *
+     * Workflow: Draft → Review analysis → Final implementation
+     */
+    revise: IReviseProps;
+  }
+
+  export interface IReviseProps {
     /**
      * Step 4: Code review and quality assessment.
      *

package/src/orchestrate/test/utils/getReferenceIds.ts

@@ -0,0 +1,25 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { OpenApiTypeChecker } from "@samchon/openapi";
+
+export const getReferenceIds = (props: {
+  document: AutoBeOpenApi.IDocument;
+  operation: AutoBeOpenApi.IOperation;
+}): string[] => {
+  const result: Set<string> = new Set();
+  const emplace = (key: string) => {
+    if (key.endsWith("_id")) result.add(key);
+  };
+
+  props.operation.parameters.forEach((p) => emplace(p.name));
+  if (props.operation.requestBody) {
+    OpenApiTypeChecker.visit({
+      components: props.document.components,
+      schema: { $ref: props.operation.requestBody.typeName },
+      closure: (schema) => {
+        if (OpenApiTypeChecker.isObject(schema) === false) return;
+        for (const key of Object.keys(schema.properties ?? {})) emplace(key);
+      },
+    });
+  }
+  return Array.from(result);
+};

package/src/structures/IAutoBeConfig.ts

@@ -16,6 +16,9 @@
  * @author Samchon
  */
 export interface IAutoBeConfig {
+  /** @default 4 */
+  retry?: number;
+
   /**
    * Language and cultural locale preference for AI agent communication.
    *

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

@@ -1,38 +0,0 @@
-import { AutoBeOpenApi, AutoBeRealizeAuthorization, AutoBeTestFile } from "@autobe/interface";
-export declare namespace IAutoBeRealizeScenarioApplication {
-    interface IProps {
-        /** The OpenAPI operation to be realized. */
-        operation: AutoBeOpenApi.IOperation;
-        /**
-         * 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;
-        /** For example, `src/providers/${function_name}.ts`. */
-        location: string;
-        /**
-         * 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.
-         */
-        testFiles: AutoBeTestFile[];
-        /**
-         * 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;
-    }
-}

package/lib/agent/src/orchestrate/realize/structures/IAutoBeRealizeScenarioApplication.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IAutoBeRealizeScenarioApplication.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/realize/structures/IAutoBeRealizeScenarioApplication.ts"],"names":[],"mappings":""}

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

@@ -1,38 +0,0 @@
-import { AutoBeOpenApi, AutoBeRealizeAuthorization, AutoBeTestFile } from "@autobe/interface";
-export declare namespace IAutoBeRealizeScenarioApplication {
-    interface IProps {
-        /** The OpenAPI operation to be realized. */
-        operation: AutoBeOpenApi.IOperation;
-        /**
-         * 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;
-        /** For example, `src/providers/${function_name}.ts`. */
-        location: string;
-        /**
-         * 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.
-         */
-        testFiles: AutoBeTestFile[];
-        /**
-         * 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;
-    }
-}