@autobe/agent 0.20.0 → 0.22.0

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -7,7 +7,6 @@ import {
   AutoBeRealizeHistory,
   AutoBeRealizeWriteEvent,
   IAutoBeCompiler,
-  IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
@@ -16,12 +15,11 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
-import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
 import { orchestrateRealizeScenario } from "./orchestrateRealizeScenario";
 import { orchestrateRealizeWrite } from "./orchestrateRealizeWrite";
-import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 
 export const orchestrateRealize =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -60,14 +58,15 @@ export const orchestrateRealize =
       await orchestrateRealizeAuthorization(ctx);
 
     // SCENARIOS
-    const scenarios: IAutoBeRealizeScenarioApplication.IProps[] =
-      operations.map((operation) => {
+    const scenarios: IAutoBeRealizeScenarioResult[] = operations.map(
+      (operation) => {
         const authorization = authorizations.find(
           (el) => el.role.name === operation.authorizationRole,
         );
 
         return orchestrateRealizeScenario(ctx, operation, authorization);
-      });
+      },
+    );
 
     const writeProgress: AutoBeProgressEventBase = {
       total: scenarios.length,
@@ -103,76 +102,20 @@ export const orchestrateRealize =
       };
     });
 
-    let compilation = await compileRealizeFiles(ctx, {
+    const reviewProgress = {
+      total: writeEvents.length,
+      completed: writeEvents.length,
+    };
+
+    const result = await orchestrateRealizeCorrect(
+      ctx,
+      scenarios,
       authorizations,
       functions,
-    });
-
-    if (compilation.type !== "success") {
-      const MAX_CORRECTION_ATTEMPTS = 5 as const;
-
-      const reviewProgress = {
-        id: v7(),
-        total: writeEvents.length,
-        completed: writeEvents.length,
-      };
-
-      for (let attempt = 0; attempt < MAX_CORRECTION_ATTEMPTS; attempt++) {
-        if (compilation.type === "failure") {
-          const failedFiles: Record<string, string> = Object.fromEntries(
-            compilation.type === "failure"
-              ? compilation.diagnostics.map((d) => [d.file, d.code])
-              : [],
-          );
-
-          reviewProgress.total += Object.keys(failedFiles).length;
-          const failure: IAutoBeTypeScriptCompileResult.IFailure = compilation;
-
-          await executeCachedBatch(
-            Object.entries(failedFiles).map(
-              ([location, content]) =>
-                async () => {
-                  const diagnostic:
-                    | IAutoBeTypeScriptCompileResult.IDiagnostic
-                    | undefined = failure.diagnostics.find(
-                    (el) => el.file === location,
-                  );
-
-                  const scenario = scenarios.find(
-                    (el) => el.location === location,
-                  );
-                  if (diagnostic && scenario) {
-                    const correctEvent = await orchestrateRealizeCorrect(ctx, {
-                      totalAuthorizations: authorizations,
-                      authorization: scenario.decoratorEvent ?? null,
-                      scenario,
-                      code: content,
-                      diagnostic,
-                      progress: reviewProgress,
-                    });
-
-                    const corrected = functions.find(
-                      (el) => el.location === correctEvent.location,
-                    );
-
-                    if (corrected) {
-                      corrected.content = correctEvent.content;
-                    }
-                  }
-                },
-            ),
-          );
-
-          compilation = await compileRealizeFiles(ctx, {
-            authorizations,
-            functions,
-          });
-          if (compilation.type === "success") {
-            break;
-          }
-        }
-      }
-    }
+      [],
+      reviewProgress,
+      5,
+    );
 
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
@@ -181,6 +124,7 @@ export const orchestrateRealize =
         functions,
         authorizations,
       });
+
     return ctx.dispatch({
       type: "realizeComplete",
       id: v7(),
@@ -188,7 +132,7 @@ export const orchestrateRealize =
       functions,
       authorizations,
       controllers,
-      compiled: await compileRealizeFiles(ctx, { authorizations, functions }),
+      compiled: result.result,
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -24,7 +24,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
   authorization: AutoBeRealizeAuthorization,
   prismaClients: Record<string, string>,
   templateFiles: Record<string, string>,
-  life: number = 4,
+  life: number = ctx.retry,
 ): Promise<AutoBeRealizeAuthorization> {
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const providerContent: string = await compiler.typescript.beautify(

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -2,7 +2,8 @@ import {
   AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeCorrectEvent,
-  IAutoBeTypeScriptCompileResult,
+  AutoBeRealizeFunction,
+  AutoBeRealizeValidateEvent,
 } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
@@ -12,33 +13,116 @@ import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
-import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformRealizeCorrectHistories } from "./histories/transformRealizeCorrectHistories";
+import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCorrectApplication";
-import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteDto } from "./utils/getRealizeWriteDto";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
+  authorizations: AutoBeRealizeAuthorization[],
+  functions: AutoBeRealizeFunction[],
+  failures: IAutoBeRealizeFunctionFailure[],
+  progress: IProgress,
+  life: number = 5,
+): Promise<AutoBeRealizeValidateEvent> {
+  const event = await compileRealizeFiles(ctx, { authorizations, functions });
+  if (event.result.type === "failure") ctx.dispatch(event);
+
+  if (event.result.type === "success") {
+    console.debug("compilation success!");
+    return event;
+  } else if (--life <= 0) return event;
+
+  const locations: string[] =
+    (event.result.type === "failure"
+      ? Array.from(new Set(event.result.diagnostics.map((d) => d.file)))
+      : null
+    )?.filter((el) => el !== null) ?? [];
+
+  progress.total += Object.keys(locations).length;
+
+  const diagnostics =
+    event.result.type === "failure" ? event.result.diagnostics : [];
+
+  const diagnosticsByFile = diagnostics.reduce<
+    Record<string, typeof diagnostics>
+  >((acc, diagnostic) => {
+    const location = diagnostic.file!;
+    if (!acc[location]) {
+      acc[location] = [];
+    }
+    acc[location].push(diagnostic);
+    return acc;
+  }, {});
+
+  for (const [location, diagnostics] of Object.entries(diagnosticsByFile)) {
+    const func = functions.find((el) => el.location === location);
+
+    if (func) {
+      failures.push({
+        function: func,
+        diagnostics,
+      });
+    }
+  }
+
+  await executeCachedBatch(
+    locations.map((location) => async (): Promise<AutoBeRealizeFunction> => {
+      const scenario = scenarios.find((el) => el.location === location);
+      const func = functions.find((el) => el.location === location)!;
+      const ReailzeFunctionFailures: IAutoBeRealizeFunctionFailure[] =
+        failures.filter((f) => f.function.location === location);
+
+      if (ReailzeFunctionFailures.length && scenario) {
+        const correctEvent = await correct(ctx, {
+          totalAuthorizations: authorizations,
+          authorization: scenario.decoratorEvent ?? null,
+          scenario,
+          function: func,
+          failures: ReailzeFunctionFailures,
+          progress: progress,
+        });
+
+        func.content = correctEvent.content;
+      }
+
+      return func;
+    }),
+  );
+
+  return orchestrateRealizeCorrect(
+    ctx,
+    scenarios,
+    authorizations,
+    functions,
+    failures,
+    progress,
+    life,
+  );
+}
+
+export async function correct<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
     authorization: AutoBeRealizeAuthorization | null;
     totalAuthorizations: AutoBeRealizeAuthorization[];
-    scenario: IAutoBeRealizeScenarioApplication.IProps;
-    code: string;
-    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+    scenario: IAutoBeRealizeScenarioResult;
+    function: AutoBeRealizeFunction;
+    failures: IAutoBeRealizeFunctionFailure[];
     progress: AutoBeProgressEventBase;
   },
 ): Promise<AutoBeRealizeCorrectEvent> {
-  const artifacts: IAutoBeTestScenarioArtifacts =
-    await getTestScenarioArtifacts(ctx, {
-      endpoint: props.scenario.operation,
-      dependencies: [],
-    });
-
   const pointer: IPointer<IAutoBeRealizeCorrectApplication.IProps | null> = {
     value: null,
   };
+
+  const dto = await getRealizeWriteDto(ctx, props.scenario.operation);
   const { tokenUsage } = await ctx.conversate({
     source: "realizeCorrect",
     controller: createController({
@@ -50,34 +134,34 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     histories: transformRealizeCorrectHistories({
       state: ctx.state(),
       scenario: props.scenario,
-      artifacts,
       authorization: props.authorization,
-      code: props.code,
-      diagnostic: props.diagnostic,
+      code: props.function.content,
+      dto,
+      failures: props.failures.filter(
+        (f) => f.function.location === props.function.location,
+      ),
       totalAuthorizations: props.totalAuthorizations,
     }),
     enforceFunctionCall: true,
     message: StringUtil.trim`
-      Correct the TypeScript code implementation to strictly follow these rules:
-      
-      1. Ensure that the code is production-ready and follows best practices.
+      Correct the TypeScript code implementation.
     `,
   });
 
   if (pointer.value === null)
     throw new Error("Failed to correct implementation code.");
 
-  pointer.value.implementationCode = await replaceImportStatements(ctx)(
-    artifacts,
-    pointer.value.implementationCode,
-    props.authorization?.payload.name,
-  );
+  pointer.value.revise.implementationCode = await replaceImportStatements(ctx, {
+    operation: props.scenario.operation,
+    code: pointer.value.revise.implementationCode,
+    decoratorType: props.authorization?.payload.name,
+  });
 
   const event: AutoBeRealizeCorrectEvent = {
     type: "realizeCorrect",
     id: v7(),
     location: props.scenario.location,
-    content: pointer.value.implementationCode,
+    content: pointer.value.revise.implementationCode,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,
@@ -120,3 +204,8 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
+
+interface IProgress {
+  total: number;
+  completed: number;
+}

package/src/orchestrate/realize/orchestrateRealizeScenario.ts

@@ -1,8 +1,12 @@
-import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import {
+  AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
+  AutoBeTestFile,
+} from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 
 /**
  * Generates a planning result that defines what kind of function should be
@@ -28,8 +32,8 @@ export const orchestrateRealizeScenario = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operation: AutoBeOpenApi.IOperation,
   authorization?: AutoBeRealizeAuthorization,
-): IAutoBeRealizeScenarioApplication.IProps => {
-  const testScenarios =
+): IAutoBeRealizeScenarioResult => {
+  const testFiles: AutoBeTestFile[] =
     ctx
       .state()
       .test?.files.filter(
@@ -47,7 +51,7 @@ export const orchestrateRealizeScenario = <Model extends ILlmSchema.Model>(
     operation: operation,
     functionName: functionName,
     location: `src/providers/${functionName}.ts`,
-    testScenarios: testScenarios.map((el) => el.scenario.draft),
+    testFiles: testFiles,
     decoratorEvent: authorization,
   };
 };

package/src/orchestrate/realize/orchestrateRealizeWrite.ts

@@ -11,11 +11,10 @@ import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
-import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
 import { transformRealizeWriteHistories } from "./histories/transformRealizeWriteHistories";
-import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { IAutoBeRealizeWriteApplication } from "./structures/IAutoBeRealizeWriteApplication";
+import { getRealizeWriteDto } from "./utils/getRealizeWriteDto";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
@@ -23,27 +22,24 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   props: {
     totalAuthorizations: AutoBeRealizeAuthorization[];
     authorization: AutoBeRealizeAuthorization | null;
-    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    scenario: IAutoBeRealizeScenarioResult;
     progress: AutoBeProgressEventBase;
     promptCacheKey: string;
   },
 ): Promise<AutoBeRealizeWriteEvent> {
-  const artifacts: IAutoBeTestScenarioArtifacts =
-    await getTestScenarioArtifacts(ctx, {
-      endpoint: props.scenario.operation,
-      dependencies: [],
-    });
   const pointer: IPointer<IAutoBeRealizeWriteApplication.IProps | null> = {
     value: null,
   };
+
+  const dto = await getRealizeWriteDto(ctx, props.scenario.operation);
   const { tokenUsage } = await ctx.conversate({
     source: "realizeWrite",
     histories: transformRealizeWriteHistories({
       state: ctx.state(),
       scenario: props.scenario,
-      artifacts,
       authorization: props.authorization,
       totalAuthorizations: props.totalAuthorizations,
+      dto,
     }),
     controller: createController({
       model: ctx.model,
@@ -73,11 +69,11 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   });
   if (pointer.value === null) throw new Error("Failed to write code.");
 
-  pointer.value.implementationCode = await replaceImportStatements(ctx)(
-    artifacts,
-    pointer.value.implementationCode,
-    props.authorization?.payload.name,
-  );
+  pointer.value.implementationCode = await replaceImportStatements(ctx, {
+    operation: props.scenario.operation,
+    code: pointer.value.implementationCode,
+    decoratorType: props.authorization?.payload.name,
+  });
 
   const event: AutoBeRealizeWriteEvent = {
     type: "realizeWrite",

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationApplication.ts

@@ -1,6 +1,23 @@
 import { CamelPattern, PascalPattern } from "@autobe/interface";
 
 export interface IAutoBeRealizeAuthorizationApplication {
+  /**
+   * Generates authentication provider, decorator, and payload type for role-based authorization.
+   *
+   * This method creates a complete authentication infrastructure for a specific
+   * role in the NestJS application. It generates three interconnected components
+   * that work together to provide JWT-based authentication and authorization.
+   *
+   * The generated components include:
+   * - **Provider Function**: Handles JWT verification and user validation from database
+   * - **Decorator**: NestJS parameter decorator for injecting authenticated user data
+   * - **Payload Type**: TypeScript interface defining the authenticated user structure
+   *
+   * All components follow strict naming conventions and integrate with the existing
+   * authentication architecture using the shared jwtAuthorize function.
+   *
+   * @param next Properties containing provider, decorator, and payload type configurations
+   */
   createDecorator: (
     next: IAutoBeRealizeAuthorizationApplication.IProps,
   ) => void;

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationCorrectApplication.ts

@@ -1,6 +1,26 @@
 import { IAutoBeRealizeAuthorizationApplication } from "./IAutoBeRealizeAuthorizationApplication";
 
 export interface IAutoBeRealizeAuthorizationCorrectApplication {
+  /**
+   * Corrects TypeScript compilation errors in authentication components.
+   *
+   * This method analyzes and fixes compilation errors in previously generated
+   * authentication provider, decorator, and payload type implementations. It
+   * performs systematic error diagnosis and generates corrected versions of
+   * all three components while maintaining their interconnected functionality.
+   *
+   * The correction process includes:
+   * - TypeScript error analysis and categorization by component
+   * - Identification of type mismatches, import issues, and syntax errors
+   * - Clear solution guidance for each identified problem
+   * - Regeneration of all components with fixes applied
+   *
+   * The corrected components maintain the same naming conventions and
+   * architectural patterns as the original generation while resolving all
+   * compilation issues.
+   *
+   * @param next Properties containing error analysis, solution guidance, and corrected components
+   */
   correctDecorator: (
     next: IAutoBeRealizeAuthorizationCorrectApplication.IProps,
   ) => void;

package/src/orchestrate/realize/structures/IAutoBeRealizeCorrectApplication.ts

@@ -1,81 +1,47 @@
-import { IAutoBeRealizeWriteApplication } from "./IAutoBeRealizeWriteApplication";
-
 export interface IAutoBeRealizeCorrectApplication {
+  /**
+   * Reviews and corrects TypeScript compilation errors.
+   *
+   * Fixes TypeScript compilation errors while preserving original business
+   * logic, applying minimal intervention principle.
+   *
+   * @param props Properties containing the multi-phase error correction process
+   */
   review: (props: IAutoBeRealizeCorrectApplication.IProps) => void;
 }
 
 export namespace IAutoBeRealizeCorrectApplication {
-  export interface IProps extends IAutoBeRealizeWriteApplication.IProps {
-    /**
-     * Compilation Error Analysis and Resolution Strategy
-     *
-     * This field contains a detailed analysis of TypeScript compilation errors
-     * that occurred during the previous compilation attempt, along with
-     * specific strategies to resolve each error.
-     *
-     * The analysis MUST include:
-     *
-     * 📊 ERROR BREAKDOWN:
-     *
-     * - List of all TypeScript error codes encountered (e.g., TS2339, TS2345)
-     * - Exact error messages and the lines/files where they occurred
-     * - Categorization of errors by type (type mismatch, missing property, etc.)
-     *
-     * 🔍 ROOT CAUSE ANALYSIS:
-     *
-     * - Why each error occurred (e.g., incorrect type assumptions, missing
-     *   fields)
-     * - Relationship between errors (e.g., cascading errors from a single issue)
-     * - Common patterns identified across multiple errors
-     *
-     * 🛠 RESOLUTION STRATEGY:
-     *
-     * - Specific fixes for each error type
-     * - Priority order for addressing errors (fix critical errors first)
-     * - Alternative approaches if the direct fix is not possible
-     *
-     * 📝 SCHEMA VERIFICATION:
-     *
-     * - Re-verification of Prisma schema fields actually available
-     * - Identification of assumed fields that don't exist
-     * - Correct field types and relationships
-     *
-     * ⚠️ COMMON ERROR PATTERNS TO CHECK:
-     *
-     * - Using non-existent fields (e.g., deleted_at, created_by)
-     * - Type mismatches in Prisma operations
-     * - Incorrect date handling (using Date instead of string)
-     * - Missing required fields in create/update operations
-     * - Incorrect relation handling in nested operations
-     *
-     * 🎯 CORRECTION APPROACH:
-     *
-     * - Remove references to non-existent fields
-     * - Fix type conversions (especially dates with toISOStringSafe())
-     * - Simplify complex nested operations into separate queries
-     * - Add missing required fields
-     * - Use correct Prisma input types
-     *
-     * Example structure:
-     *
-     *     Errors Found:
-     *     1. TS2339: Property 'deleted_at' does not exist on type 'User'
-     *        - Cause: Field assumed but not in schema
-     *        - Fix: Remove all deleted_at references
-     *
-     *     2. TS2345: Type 'Date' is not assignable to type 'string'
-     *        - Cause: Direct Date assignment without conversion
-     *        - Fix: Use toISOStringSafe() for all date values
-     *
-     *     Resolution Plan:
-     *     1. First, remove all non-existent field references
-     *     2. Then, fix all date type conversions
-     *     3. Finally, adjust Prisma query structures
-     *
-     * This analysis ensures the review process addresses all compilation errors
-     * systematically and produces error-free code in the corrected
-     * implementation.
-     */
-    errorAnalysis: string;
+  /**
+   * Properties for error correction following Chain of Thinking (CoT).
+   *
+   * All phases are wrapped in a `revise` object for systematic error
+   * resolution.
+   */
+  export interface IProps {
+    /** Revision process containing all error correction phases. */
+    revise: IRevise;
+  }
+
+  export interface IRevise {
+    /** Step 1: Compilation error analysis and resolution strategy. */
+    errorAnalysis?: string;
+
+    /** Step 2: Provider function implementation plan. */
+    plan?: string;
+
+    /** Step 3: Relevant Prisma schema definitions. */
+    prismaSchemas?: string;
+
+    /** Step 4: Initial draft without using native Date type. */
+    draftWithoutDateType?: string;
+
+    /** Step 5: Refined version with improved completeness. */
+    review?: string;
+
+    /** Step 6: Corrected implementation after compiler feedback. */
+    withCompilerFeedback?: string;
+
+    /** Step 7: Final complete TypeScript function implementation. */
+    implementationCode: string;
   }
 }

package/src/orchestrate/realize/structures/IAutoBeRealizeFunctionFailure.ts

@@ -0,0 +1,9 @@
+import {
+  AutoBeRealizeFunction,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+
+export interface IAutoBeRealizeFunctionFailure {
+  function: AutoBeRealizeFunction;
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+}

package/src/orchestrate/realize/structures/IAutoBeRealizeScenarioResult.ts

@@ -0,0 +1,45 @@
+import {
+  AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
+  AutoBeTestFile,
+} from "@autobe/interface";
+
+export interface IAutoBeRealizeScenarioResult {
+  /** 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;
+}