@autobe/agent 0.21.0 → 0.22.0

package/src/orchestrate/realize/histories/transformRealizeCorrectHistories.ts

@@ -1,25 +1,22 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import {
-  AutoBeRealizeAuthorization,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
+import { AutoBeRealizeAuthorization } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
-import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
 import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
 
 export function transformRealizeCorrectHistories(props: {
   state: AutoBeState;
-  scenario: IAutoBeRealizeScenarioApplication.IProps;
-  artifacts: IAutoBeTestScenarioArtifacts;
+  scenario: IAutoBeRealizeScenarioResult;
   authorization: AutoBeRealizeAuthorization | null;
   totalAuthorizations: AutoBeRealizeAuthorization[];
   code: string;
-  diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+  dto: Record<string, string>;
+  failures: IAutoBeRealizeFunctionFailure[];
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > {
@@ -34,15 +31,33 @@ export function transformRealizeCorrectHistories(props: {
         \`\`\`typescript
         ${props.code}
         \`\`\`
-
-        The code has a compilation error:
-        
-        \`\`\`json
-        ${JSON.stringify(props.diagnostic)}
-        \`\`\`
       `,
       created_at: new Date().toISOString(),
     },
+    ...props.failures.map(
+      (f) =>
+        ({
+          id: v7(),
+          type: "assistantMessage",
+          text: StringUtil.trim`
+
+      ## Generated Typescript Code
+
+      \`\`\`typescript
+      ${f.function.content}
+      \`\`\`
+
+      ## Compile Errors
+
+      Fix the comilation error in the provided code.
+
+      \`\`\`typescript
+      ${JSON.stringify(f.diagnostics)}
+      \`\`\`
+      `,
+          created_at: new Date().toISOString(),
+        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ),
     {
       id: v7(),
       type: "systemMessage",

package/src/orchestrate/realize/histories/transformRealizeWriteHistories.ts

@@ -5,13 +5,18 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
-import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteCodeTemplate } from "../utils/getRealizeWriteCodeTemplate";
+import { getRealizeWriteInputType } from "../utils/getRealizeWriteInputType";
 import { transformRealizeWriteAuthorizationsHistories } from "./transformRealizeWriteAuthorizationsHistories";
 
-export const transformRealizeWriteHistories = (
-  props: IProps,
-): Array<
+export const transformRealizeWriteHistories = (props: {
+  state: AutoBeState;
+  scenario: IAutoBeRealizeScenarioResult;
+  authorization: AutoBeRealizeAuthorization | null;
+  totalAuthorizations: AutoBeRealizeAuthorization[];
+  dto: Record<string, string>;
+}): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   const payloads = Object.fromEntries(
@@ -21,38 +26,7 @@ export const transformRealizeWriteHistories = (
     ]),
   );
 
-  const [operation] = props.artifacts.document.operations;
-
-  const propsFields: string[] = [];
-
-  // payload 추가
-  if (props.authorization && operation.authorizationRole) {
-    propsFields.push(
-      `${operation.authorizationRole}: ${props.authorization.payload.name};`,
-    );
-  }
-
-  // parameters 추가
-  operation.parameters.forEach((parameter) => {
-    const format =
-      "format" in parameter.schema
-        ? ` & tags.Format<'${parameter.schema.format}'>`
-        : "";
-    propsFields.push(`${parameter.name}: ${parameter.schema.type}${format};`);
-  });
-
-  // body 추가
-  if (operation.requestBody?.typeName) {
-    propsFields.push(`body: ${operation.requestBody.typeName};`);
-  }
-
-  const input =
-    propsFields.length > 0
-      ? StringUtil.trim`
-        props: {
-        ${propsFields.map((field) => `  ${field},`).join("\n")}
-        }`
-      : `// No props parameter needed - function should have no parameters`;
+  const operation = props.scenario.operation;
 
   if (props.state.analyze === null)
     return [
@@ -132,7 +106,7 @@ export const transformRealizeWriteHistories = (
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_WRITE_TOTAL,
+      text: AutoBeSystemPromptConstant.REALIZE_WRITE,
     },
     ...authorizationHistories,
     {
@@ -143,14 +117,26 @@ export const transformRealizeWriteHistories = (
         `{prisma_schemas}`,
         JSON.stringify(props.state.prisma.schemas),
       )
-        .replaceAll(`{artifacts_sdk}`, JSON.stringify(props.artifacts.sdk))
-        .replaceAll(`{artifacts_dto}`, JSON.stringify(props.artifacts.dto))
-        .replaceAll(`{input}`, input),
+        .replaceAll(
+          `{input}`,
+          getRealizeWriteInputType(operation, props.authorization),
+        )
+        .replaceAll(`{artifacts_dto}`, JSON.stringify(props.dto)),
     },
     {
       id: v7(),
+      type: "systemMessage",
       created_at: new Date().toISOString(),
+      text: getRealizeWriteCodeTemplate(
+        props.scenario,
+        operation,
+        props.authorization,
+      ),
+    },
+    {
+      id: v7(),
       type: "systemMessage",
+      created_at: new Date().toISOString(),
       text: StringUtil.trim`
         Write new code based on the following operation.
         
@@ -179,11 +165,3 @@ export const transformRealizeWriteHistories = (
     },
   ];
 };
-
-interface IProps {
-  state: AutoBeState;
-  scenario: IAutoBeRealizeScenarioApplication.IProps;
-  artifacts: IAutoBeTestScenarioArtifacts;
-  authorization: AutoBeRealizeAuthorization | null;
-  totalAuthorizations: AutoBeRealizeAuthorization[];
-}

package/src/orchestrate/realize/internal/compileRealizeFiles.ts

@@ -16,7 +16,7 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
     authorizations: AutoBeRealizeAuthorization[];
     functions: AutoBeRealizeFunction[];
   },
-): Promise<IAutoBeTypeScriptCompileResult> {
+): Promise<AutoBeRealizeValidateEvent> {
   const prisma = ctx.state().prisma?.compiled;
   const payloads: Record<string, string> = Object.fromEntries(
     props.authorizations.map((el) => [el.payload.location, el.payload.content]),
@@ -50,22 +50,15 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
     await compiler.typescript.compile({
       files: files,
     });
-  if (compiled.type === "success") {
-    return compiled;
-  }
 
   const event: AutoBeRealizeValidateEvent = {
     type: "realizeValidate",
     id: v7(),
+    files: files,
     result: compiled,
-    files: Object.fromEntries(
-      compiled.type === "failure"
-        ? compiled.diagnostics.map((d) => [d.file, d.code])
-        : [],
-    ),
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };
-  ctx.dispatch(event);
-  return compiled;
+
+  return event;
 }

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

@@ -6,7 +6,7 @@ import {
 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
@@ -32,7 +32,7 @@ export const orchestrateRealizeScenario = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operation: AutoBeOpenApi.IOperation,
   authorization?: AutoBeRealizeAuthorization,
-): IAutoBeRealizeScenarioApplication.IProps => {
+): IAutoBeRealizeScenarioResult => {
   const testFiles: AutoBeTestFile[] =
     ctx
       .state()

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;