@autobe/agent 0.16.1 → 0.18.0

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -4,16 +4,22 @@ import {
   AutoBeRealizeAuthorization,
   AutoBeRealizeFunction,
   AutoBeRealizeHistory,
+  AutoBeRealizeWriteEvent,
   IAutoBeCompiler,
+  IAutoBeTypeScriptCompileResult,
 } 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 { compile } from "./internal/compile";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
-import { writeCodeUntilCompilePassed } from "./writeCodeUntilCompilePassed";
+import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
+import { orchestrateRealizeScenario } from "./orchestrateRealizeScenario";
+import { orchestrateRealizeWrite } from "./orchestrateRealizeWrite";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
 
 export const orchestrateRealize =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -29,23 +35,107 @@ export const orchestrateRealize =
     const start: Date = new Date();
     ctx.dispatch({
       type: "realizeStart",
-      created_at: new Date().toISOString(),
+      created_at: start.toISOString(),
       reason: props.reason,
       step: ctx.state().test?.step ?? 0,
     });
 
-    // generate authorizations and functions
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
-    const result = await writeCodeUntilCompilePassed(ctx)({
-      operations,
+
+    const scenarios: IAutoBeRealizeScenarioApplication.IProps[] =
+      operations.map((operation) => orchestrateRealizeScenario(ctx, operation));
+
+    const writeProgress = { total: scenarios.length, completed: 0 };
+    const writeEvents: AutoBeRealizeWriteEvent[] = await Promise.all(
+      scenarios.map(async (scenario) => {
+        const code = orchestrateRealizeWrite(
+          ctx,
+          scenario.decoratorEvent ?? null,
+          scenario,
+          writeProgress,
+        );
+        return code;
+      }),
+    );
+
+    let providers = Object.fromEntries(
+      writeEvents.map((event) => [event.location, event.content]),
+    );
+
+    let finalCompilationResult = await compile(ctx, {
       authorizations,
-      retry: 4,
+      providers,
     });
 
-    const functions: AutoBeRealizeFunction[] = result.functions;
+    if (finalCompilationResult.type !== "success") {
+      const MAX_CORRECTION_ATTEMPTS = 3 as const;
+
+      const reviewProgress = {
+        total: writeEvents.length,
+        completed: writeEvents.length,
+      };
+
+      for (let attempt = 0; attempt < MAX_CORRECTION_ATTEMPTS; attempt++) {
+        if (finalCompilationResult.result.type === "failure") {
+          const failedFiles: Record<string, string> =
+            finalCompilationResult.files;
+
+          reviewProgress.total += Object.keys(failedFiles).length;
+          const compilationResult: IAutoBeTypeScriptCompileResult.IFailure =
+            finalCompilationResult.result;
+
+          await Promise.all(
+            Object.entries(failedFiles).map(async ([location, content]) => {
+              const diagnostic:
+                | IAutoBeTypeScriptCompileResult.IDiagnostic
+                | undefined = compilationResult.diagnostics.find(
+                (el) => el.file === location,
+              );
+
+              const scenario = scenarios.find((el) => el.location === location);
+              if (diagnostic && scenario) {
+                const correctEvent = await orchestrateRealizeCorrect(
+                  ctx,
+                  scenario.decoratorEvent ?? null,
+                  scenario,
+                  content,
+                  diagnostic,
+                  reviewProgress,
+                );
+
+                providers[correctEvent.location] = correctEvent.content;
+              }
+            }),
+          );
+
+          finalCompilationResult = await compile(ctx, {
+            authorizations,
+            providers,
+          });
+
+          if (finalCompilationResult.type === "success") {
+            break;
+          }
+        }
+      }
+    }
+
+    const functions: AutoBeRealizeFunction[] = Object.entries(providers).map(
+      ([location, content]) => {
+        const scenario = scenarios.find((el) => el.location === location)!;
+        return {
+          location,
+          content,
+          endpoint: {
+            method: scenario.operation.method,
+            path: scenario.operation.path,
+          },
+          name: scenario.functionName,
+        };
+      },
+    );
 
-    // compile controllers
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
@@ -54,41 +144,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,
+      elapsed: new Date().getTime() - start.getTime(),
     });
-    ctx.state().realize = history;
-    ctx.histories().push(history);
-
-    return history;
   };

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -1,15 +1,20 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import { AutoBeRealizeAuthorization, IAutoBeCompiler } from "@autobe/interface";
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyzeRole,
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeAuthorizationWriteEvent,
+  IAutoBeCompiler,
+} from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
+import { IProgress } from "../internal/IProgress";
+import { transformRealizeAuthorizationHistories } from "./histories/transformRealizeAuthorization";
 import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
 import { IAutoBeRealizeAuthorizationApplication } from "./structures/IAutoBeRealizeAuthorizationApplication";
-import { transformRealizeAuthorizationHistories } from "./transformRealizeAuthorization";
 import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
 import { InternalFileSystem } from "./utils/InternalFileSystem";
 
@@ -22,37 +27,29 @@ import { InternalFileSystem } from "./utils/InternalFileSystem";
 export async function orchestrateRealizeAuthorization<
   Model extends ILlmSchema.Model,
 >(ctx: AutoBeContext<Model>): Promise<AutoBeRealizeAuthorization[]> {
-  const roles = ctx.state().analyze?.roles.map((role) => role.name) ?? [];
-
-  let completed = 0;
-
-  const templateFiles = await (await ctx.compiler()).realize.getTemplate();
-
   ctx.dispatch({
     type: "realizeAuthorizationStart",
     step: ctx.state().test?.step ?? 0,
     created_at: new Date().toISOString(),
   });
 
+  const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
+  const progress: IProgress = {
+    total: roles.length,
+    completed: 0,
+  };
+  const templateFiles = await (await ctx.compiler()).realize.getTemplate();
   const authorizations: AutoBeRealizeAuthorization[] = await Promise.all(
-    roles.map(async (role) => {
-      const authorization: AutoBeRealizeAuthorization = await process(
+    roles.map((role) =>
+      process(
         ctx,
         role,
         InternalFileSystem.DEFAULT.map((el) => ({
           [el]: templateFiles[el],
         })).reduce((acc, cur) => Object.assign(acc, cur), {}),
-      );
-      ctx.dispatch({
-        type: "realizeAuthorizationWrite",
-        created_at: new Date().toISOString(),
-        authorization: authorization,
-        completed: ++completed,
-        total: roles.length,
-        step: ctx.state().test?.step ?? 0,
-      });
-      return authorization;
-    }),
+        progress,
+      ),
+    ),
   );
   ctx.dispatch({
     type: "realizeAuthorizationComplete",
@@ -64,40 +61,26 @@ export async function orchestrateRealizeAuthorization<
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  role: string,
+  role: AutoBeAnalyzeRole,
   templateFiles: Record<string, string>,
+  progress: IProgress,
 ): Promise<AutoBeRealizeAuthorization> {
   const pointer: IPointer<IAutoBeRealizeAuthorizationApplication.IProps | null> =
     {
       value: null,
     };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-    },
+  const { tokenUsage } = await ctx.conversate({
+    source: "realizeAuthorizationWrite",
     histories: transformRealizeAuthorizationHistories(ctx, role),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Create Authorization Provider and Decorator.",
   });
-  enforceToolCall(agentica);
-
-  await agentica
-    .conversate("Create Authorization Provider and Decorator.")
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
-      ctx.usage().record(tokenUsage, ["realize"]);
-    });
   if (pointer.value === null) throw new Error("Failed to create decorator.");
 
   const compiler: IAutoBeCompiler = await ctx.compiler();
@@ -129,6 +112,15 @@ async function process<Model extends ILlmSchema.Model>(
   const prismaClients: Record<string, string> =
     compiled?.type === "success" ? compiled.nodeModules : {};
 
+  ctx.dispatch({
+    type: "realizeAuthorizationWrite",
+    created_at: new Date().toISOString(),
+    authorization: authorization,
+    tokenUsage,
+    completed: ++progress.completed,
+    total: progress.total,
+    step: ctx.state().test?.step ?? 0,
+  } satisfies AutoBeRealizeAuthorizationWriteEvent);
   return orchestrateRealizeAuthorizationCorrect(
     ctx,
     authorization,
@@ -137,7 +129,7 @@ async function process<Model extends ILlmSchema.Model>(
   );
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: IAutoBeRealizeAuthorizationApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
@@ -145,7 +137,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -161,16 +153,12 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
 const claude = typia.llm.application<
   IAutoBeRealizeAuthorizationApplication,
-  "claude",
-  {
-    reference: true;
-  }
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
     IAutoBeRealizeAuthorizationApplication,
-    "chatgpt",
-    { reference: true }
+    "chatgpt"
   >(),
   claude,
   llama: claude,

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -1,4 +1,4 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeRealizeAuthorization,
   AutoBeRealizeAuthorizationCorrect,
@@ -11,9 +11,8 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
+import { transformRealizeAuthorizationCorrectHistories } from "./histories/transformRealizeAuthorizationCorrectHistories";
 import { IAutoBeRealizeAuthorizationCorrectApplication } from "./structures/IAutoBeRealizeAuthorizationCorrectApplication";
-import { transformRealizeAuthorizationCorrectHistories } from "./transformRealizeAuthorizationCorrectHistories";
 import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
 import { AutoBeRealizeAuthorizationReplaceImport } from "./utils/AutoBeRealizeAuthorizationReplaceImport";
 
@@ -29,13 +28,13 @@ export async function orchestrateRealizeAuthorizationCorrect<
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const providerContent: string = await compiler.typescript.beautify(
     AutoBeRealizeAuthorizationReplaceImport.replaceProviderImport(
-      authorization.role,
+      authorization.role.name,
       authorization.provider.content,
     ),
   );
   const decoratorContent: string = await compiler.typescript.beautify(
     AutoBeRealizeAuthorizationReplaceImport.replaceDecoratorImport(
-      authorization.role,
+      authorization.role.name,
       authorization.decorator.content,
     ),
   );
@@ -75,40 +74,23 @@ export async function orchestrateRealizeAuthorizationCorrect<
     {
       value: null,
     };
-
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-    },
+  const { tokenUsage } = await ctx.conversate({
+    source: "realizeAuthorizationCorrect",
     histories: transformRealizeAuthorizationCorrectHistories(
       ctx,
       authorization,
       templateFiles,
       compiled.diagnostics,
     ),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Please correct the decorator and the provider.",
   });
-  enforceToolCall(agentica);
-
-  await agentica
-    .conversate("Please correct the decorator and the provider.")
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
-      ctx.usage().record(tokenUsage, ["realize"]);
-    });
-
   if (pointer.value === null) throw new Error("Failed to correct decorator.");
 
   const result: AutoBeRealizeAuthorizationCorrect = {
@@ -141,6 +123,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
     created_at: new Date().toISOString(),
     authorization: result,
     result: compiled,
+    tokenUsage,
     step: ctx.state().test?.step ?? 0,
   });
 
@@ -153,7 +136,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
   );
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: IAutoBeRealizeAuthorizationCorrectApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
@@ -161,8 +144,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
-
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "Correct Authorization",
@@ -177,16 +159,12 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
 const claude = typia.llm.application<
   IAutoBeRealizeAuthorizationCorrectApplication,
-  "claude",
-  {
-    reference: true;
-  }
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
     IAutoBeRealizeAuthorizationCorrectApplication,
-    "chatgpt",
-    { reference: true }
+    "chatgpt"
   >(),
   claude,
   llama: claude,

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -0,0 +1,118 @@
+import {
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeCorrectEvent,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
+import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
+import { transformRealizeCorrectHistories } from "./histories/transformRealizeCorrectHistories";
+import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeReviewApplication";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { replaceImportStatements } from "./utils/replaceImportStatements";
+
+export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  authorization: AutoBeRealizeAuthorization | null,
+  scenario: IAutoBeRealizeScenarioApplication.IProps,
+  code: string,
+  diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic,
+  progress: IProgress,
+): Promise<AutoBeRealizeCorrectEvent> {
+  const artifacts: IAutoBeTestScenarioArtifacts =
+    await getTestScenarioArtifacts(ctx, {
+      endpoint: scenario.operation,
+      dependencies: [],
+    });
+
+  const pointer: IPointer<IAutoBeRealizeCorrectApplication.IProps | null> = {
+    value: null,
+  };
+  const { tokenUsage } = await ctx.conversate({
+    source: "realizeCorrect",
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    histories: transformRealizeCorrectHistories({
+      state: ctx.state(),
+      scenario,
+      artifacts,
+      authorization,
+      code,
+      diagnostic,
+    }),
+    enforceFunctionCall: true,
+    message: [
+      `Correct the TypeScript code implementation to strictly follow these rules:`,
+      `1. Ensure that the code is production-ready and follows best practices.`,
+    ].join("\n"),
+  });
+
+  if (pointer.value === null)
+    throw new Error("Failed to correct implementation code.");
+
+  pointer.value.implementationCode = await replaceImportStatements(ctx)(
+    artifacts,
+    pointer.value.implementationCode,
+    authorization?.payload.name,
+  );
+
+  const event: AutoBeRealizeCorrectEvent = {
+    type: "realizeCorrect",
+    location: scenario.location,
+    content: pointer.value.implementationCode,
+    tokenUsage,
+    completed: ++progress.completed,
+    total: progress.total,
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  };
+  ctx.dispatch(event);
+  return event;
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IAutoBeRealizeCorrectApplication.IProps) => void;
+}): ILlmController<Model> {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: "Write code",
+    application,
+    execute: {
+      review: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeRealizeCorrectApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeRealizeCorrectApplication,
+  "claude"
+>();
+const collection = {
+  chatgpt: typia.llm.application<IAutoBeRealizeCorrectApplication, "chatgpt">(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};
+
+export interface IProgress {
+  total: number;
+  completed: number;
+}

package/src/orchestrate/realize/{orchestrateRealizePlanner.ts → orchestrateRealizeScenario.ts}

@@ -2,8 +2,9 @@ import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
 
-export interface RealizePlannerOutput {
+export interface IAutoBeRealizeScenario {
   /**
    * The name of the function to be generated.
    *
@@ -56,7 +57,7 @@ export interface RealizePlannerOutput {
    * Extracted from the Swagger operation method. Used to define the request
    * type during code and test generation.
    */
-  operationType: "get" | "post" | "put" | "delete" | "patch";
+  method: "get" | "post" | "put" | "delete" | "patch";
 
   /**
    * List of scenario descriptions for test code generation.
@@ -91,16 +92,17 @@ export interface RealizePlannerOutput {
  * next step in the AutoBE pipeline, which is responsible for generating the
  * actual implementation code.
  *
+ * @author Kakasoo
  * @param ctx - AutoBE context including model and configuration
  * @param operation - A single OpenAPI operation object to analyze and plan
  * @returns A planning object containing all structural information needed to
  *   generate the function
  */
-export const orchestrateRealizePlanner = async <Model extends ILlmSchema.Model>(
+export const orchestrateRealizeScenario = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operation: AutoBeOpenApi.IOperation,
   authorization?: AutoBeRealizeAuthorization,
-): Promise<RealizePlannerOutput> => {
+): IAutoBeRealizeScenarioApplication.IProps => {
   const testScenarios =
     ctx
       .state()
@@ -110,18 +112,16 @@ export const orchestrateRealizePlanner = async <Model extends ILlmSchema.Model>(
           el.scenario.endpoint.path === operation.path,
       ) ?? [];
 
+  const functionName = `${operation.method}_${operation.path
+    .replaceAll("/", "_")
+    .replaceAll("-", "_")
+    .replaceAll("{", "$")
+    .replaceAll("}", "")}`;
   return {
-    description: operation.description,
-    parameters: operation.parameters,
-    inputSchema: operation.requestBody,
-    outputSchema: operation.responseBody,
-    operationType: operation.method,
+    operation: operation,
+    functionName: functionName,
+    location: `src/providers/${functionName}.ts`,
     testScenarios: testScenarios.map((el) => el.scenario.draft),
-    functionName: `${operation.method}_${operation.path
-      .replaceAll("/", "_")
-      .replaceAll("-", "_")
-      .replaceAll("{", "$")
-      .replaceAll("}", "")}`,
     decoratorEvent: authorization,
-  } satisfies RealizePlannerOutput;
+  };
 };