@autobe/agent 0.13.0 → 0.14.2

package/src/factory/getAutoBeGenerated.ts

@@ -93,11 +93,26 @@ export async function getAutoBeGenerated(
 
   // REALIZE
   if (state.realize?.step === state.analyze.step)
-    Object.assign<
-      Record<string, string>,
-      Record<string, string>,
-      Record<string, string>
-    >(ret, state.realize.files, await compiler.realize.getTemplate());
+    Object.assign<Record<string, string>, Record<string, string>>(ret, {
+      ...Object.fromEntries(
+        state.realize.functions.map((f) => [f.location, f.content]),
+      ),
+      ...Object.fromEntries(
+        state.realize.authorizations
+          .map((auth) => [
+            [auth.decorator.location, auth.decorator.content],
+            [auth.provider.location, auth.provider.content],
+            [auth.payload.location, auth.payload.content],
+          ])
+          .flat(),
+      ),
+      ...(await compiler.realize.getTemplate()),
+      ...(await compiler.realize.controller({
+        document: state.interface!.document,
+        functions: state.realize.functions,
+        authorizations: state.realize.authorizations,
+      })),
+    });
 
   // LOGGING
   Object.assign<Record<string, string>, Record<string, string>>(ret, {

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -119,6 +119,15 @@ async function process<Model extends ILlmSchema.Model>(
       [
         "Make API operations for below endpoints:",
         "",
+        "**CRITICAL INSTRUCTIONS**:",
+        "1. Base ALL operation descriptions on ACTUAL fields in the Prisma schema",
+        "2. NEVER reference fields that don't exist (e.g., deleted_at, created_by, updated_by)",
+        "3. For DELETE operations:",
+        "   - Check if the entity has soft delete fields in the schema",
+        "   - If YES: Describe soft delete behavior using those fields",
+        "   - If NO: Describe hard delete behavior (permanent removal)",
+        "4. Every field mentioned in descriptions MUST exist in the Prisma schema",
+        "",
         "```json",
         JSON.stringify(Array.from(endpoints), null, 2),
         "```",
@@ -156,24 +165,23 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
             "GET method should not have request body. Change method, or re-design the operation.",
           value: op.requestBody,
         });
-      op.authorizationRoles?.forEach((role, j) => {
-        if (props.roles === null) {
-          op.authorizationRoles = null;
-        }
-        if (props.roles?.find((it) => it === role) === undefined)
-          errors.push({
-            path: `operations[${i}].authorizationRoles[${j}]`,
-            expected: `undefined | ${props.roles?.join(" | ")}`,
-            description: [
-              `Role "${role}" is not defined in the roles list.`,
-              "",
-              "Please select one of them below, or do not define (undefined):  ",
-              "",
-              ...(props.roles ?? []).map((role) => `- ${role}`),
-            ].join("\n"),
-            value: role,
-          });
-      });
+      if (props.roles === null) {
+        op.authorizationRole = null;
+      } else if (
+        props.roles?.find((it) => it === op.authorizationRole) === undefined
+      )
+        errors.push({
+          path: `operations[${i}].authorizationRole`,
+          expected: `undefined | ${props.roles?.join(" | ")}`,
+          description: [
+            `Role "${op.authorizationRole}" is not defined in the roles list.`,
+            "",
+            "Please select one of them below, or do not define (undefined):  ",
+            "",
+            ...(props.roles ?? []).map((role) => `- ${role}`),
+          ].join("\n"),
+          value: op.authorizationRole,
+        });
     });
     if (errors.length !== 0)
       return {

package/src/orchestrate/interface/transformInterfaceHistories.ts

@@ -127,6 +127,16 @@ export const transformInterfaceHistories = (
         "You should also look at this and consider logic including membership/login and token issuance.",
         "You can use table's name to define role in operations.",
         "",
+        "## Critical Schema Verification Instructions",
+        "",
+        "**IMPORTANT**: When generating API operations and descriptions:",
+        "1. ONLY reference fields that ACTUALLY EXIST in the Prisma schema below",
+        "2. NEVER assume common fields like `deleted_at`, `created_by`, `updated_by`, `is_deleted` exist",
+        "3. For DELETE operations:",
+        "   - If schema HAS soft delete fields (e.g., `deleted_at`), describe soft delete behavior",
+        "   - If schema LACKS soft delete fields, describe hard delete behavior",
+        "4. Verify EVERY field reference against the actual schema before including in descriptions",
+        "",
         "## Prisma DB Schema",
         "```json",
         JSON.stringify(state.prisma.schemas),

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -1,5 +1,6 @@
 import {
   AutoBeAssistantMessageHistory,
+  AutoBeRealizeAuthorization,
   AutoBeRealizeHistory,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
@@ -7,7 +8,7 @@ import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-import { orchestrateRealizeDecorator } from "./orchestrateRealizeDecorator";
+import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { writeCodeUntilCompilePassed } from "./writeCodeUntilCompilePassed";
 
 export const orchestrateRealize =
@@ -28,11 +29,32 @@ export const orchestrateRealize =
       step: ctx.state().test?.step ?? 0,
     });
 
-    const decorators = await orchestrateRealizeDecorator(ctx);
-    decorators;
+    const decorators: AutoBeRealizeAuthorization[] =
+      await orchestrateRealizeAuthorization(ctx);
+    const files = await writeCodeUntilCompilePassed(ctx, ops, decorators, 2);
 
-    await writeCodeUntilCompilePassed(ctx, ops, 3);
     const now = new Date().toISOString();
+    const realize = ctx.state().realize;
+    if (realize !== null) {
+      realize.functions = files;
+    } else {
+      const history = (ctx.state().realize = {
+        type: "realize",
+        compiled: {
+          type: "success",
+        },
+        functions: files,
+        completed_at: now,
+        created_at: now,
+        id: v4(),
+        reason: props.reason,
+        step: ctx.state().analyze?.step ?? 0,
+        authorizations: ctx.state().realize?.authorizations ?? [],
+      } satisfies AutoBeRealizeHistory);
+
+      ctx.histories().push(history);
+    }
+
     ctx.dispatch({
       type: "assistantMessage",
       text: "Any codes can not be generated.",
@@ -41,12 +63,15 @@ export const orchestrateRealize =
 
     return {
       type: "realize",
-      compiled: 1 as any,
-      files: {},
+      compiled: {
+        type: "success",
+      },
+      functions: files,
       completed_at: now,
       created_at: now,
       id: v4(),
       reason: props.reason,
-      step: ctx.state().test?.step ?? 0,
+      step: ctx.state().analyze?.step ?? 0,
+      authorizations: ctx.state().realize?.authorizations ?? [],
     };
   };

package/src/orchestrate/realize/{orchestrateRealizeDecorator.ts → orchestrateRealizeAuthorization.ts}

@@ -1,7 +1,8 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import {
-  AutoBeRealizeDecoratorEvent,
+  AutoBeRealizeAuthorization,
   IAutoBeCompiler,
+  IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import fs from "fs/promises";
@@ -15,6 +16,7 @@ import { enforceToolCall } from "../../utils/enforceToolCall";
 import { IAutoBeRealizeDecoratorApplication } from "./structures/IAutoBeRealizeDecoratorApplication";
 import { transformRealizeDecoratorHistories } from "./transformRealizeDecorator";
 import { transformRealizeDecoratorCorrectHistories } from "./transformRealizeDecoratorCorrectHistories";
+import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
 
 /**
  * 1. Create decorator and its parameters. and design the Authorization Provider.
@@ -22,19 +24,15 @@ import { transformRealizeDecoratorCorrectHistories } from "./transformRealizeDec
  *
  * @param ctx
  */
-export async function orchestrateRealizeDecorator<
+export async function orchestrateRealizeAuthorization<
   Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-): Promise<IAutoBeRealizeDecoratorApplication.IProps[]> {
+>(ctx: AutoBeContext<Model>): Promise<AutoBeRealizeAuthorization[]> {
   const roles =
     ctx
       .state()
       .interface?.document.components.authorization?.map((auth) => auth.name) ??
     [];
 
-  const decorators: IAutoBeRealizeDecoratorApplication.IProps[] = [];
-
   let completed = 0;
 
   const templateFiles = {
@@ -54,49 +52,45 @@ export async function orchestrateRealizeDecorator<
     ),
   };
 
-  const files: Record<string, string> = {
-    ...templateFiles,
-  };
-
-  await Promise.all(
+  ctx.dispatch({
+    type: "realizeAuthorizationStart",
+    step: ctx.state().test?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
+  const authorizations: AutoBeRealizeAuthorization[] = await Promise.all(
     roles.map(async (role) => {
-      const decorator: IAutoBeRealizeDecoratorApplication.IProps =
-        await process(ctx, role, templateFiles);
-
-      files[`src/decorators/${decorator.decorator.name}.ts`] =
-        decorator.decorator.code;
-      files[`src/authentications/${decorator.provider.name}.ts`] =
-        decorator.provider.code;
-      files[`src/authentications/types/${decorator.decoratorType.name}.ts`] =
-        decorator.decoratorType.code;
-
-      decorators.push(decorator);
-
-      const events: AutoBeRealizeDecoratorEvent = {
-        type: "realizeDecorator",
+      const authorization: AutoBeRealizeAuthorization = await process(
+        ctx,
+        role,
+        templateFiles,
+      );
+      ctx.dispatch({
+        type: "realizeAuthorizationWrite",
         created_at: new Date().toISOString(),
-        files,
+        authorization: authorization,
         completed: ++completed,
         total: roles.length,
         step: ctx.state().test?.step ?? 0,
-      };
-
-      ctx.dispatch(events);
+      });
+      return authorization;
     }),
   );
-
-  return decorators;
+  ctx.dispatch({
+    type: "realizeAuthorizationComplete",
+    created_at: new Date().toISOString(),
+    step: ctx.state().test?.step ?? 0,
+  });
+  return authorizations;
 }
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   role: string,
   templateFiles: Record<string, string>,
-): Promise<IAutoBeRealizeDecoratorApplication.IProps> {
+): Promise<AutoBeRealizeAuthorization> {
   const pointer: IPointer<IAutoBeRealizeDecoratorApplication.IProps | null> = {
     value: null,
   };
-
   const agentica: MicroAgentica<Model> = new MicroAgentica({
     model: ctx.model,
     vendor: ctx.vendor,
@@ -116,7 +110,6 @@ async function process<Model extends ILlmSchema.Model>(
       }),
     ],
   });
-
   enforceToolCall(agentica);
 
   await agentica
@@ -125,63 +118,73 @@ async function process<Model extends ILlmSchema.Model>(
       const tokenUsage = agentica.getTokenUsage();
       ctx.usage().record(tokenUsage, ["realize"]);
     });
-
   if (pointer.value === null) throw new Error("Failed to create decorator.");
 
+  const authorization: AutoBeRealizeAuthorization = {
+    role,
+    decorator: {
+      location: AuthorizationFileSystem.decoratorPath(
+        pointer.value.decorator.name,
+      ),
+      name: pointer.value.decorator.name,
+      content: pointer.value.decorator.code,
+    },
+    payload: {
+      location: AuthorizationFileSystem.payloadPath(pointer.value.payload.name),
+      name: pointer.value.payload.name,
+      content: pointer.value.payload.code,
+    },
+    provider: {
+      location: AuthorizationFileSystem.providerPath(
+        pointer.value.provider.name,
+      ),
+      name: pointer.value.provider.name,
+      content: pointer.value.provider.code,
+    },
+  };
   const compiled = ctx.state().prisma?.compiled;
-
   const prismaClients: Record<string, string> =
     compiled?.type === "success" ? compiled.nodeModules : {};
-
-  return await correctDecorator(
-    ctx,
-    pointer.value,
-    prismaClients,
-    templateFiles,
-  );
+  return correctDecorator(ctx, authorization, prismaClients, templateFiles);
 }
 
 async function correctDecorator<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  result: IAutoBeRealizeDecoratorApplication.IProps,
+  auth: AutoBeRealizeAuthorization,
   prismaClients: Record<string, string>,
   templateFiles: Record<string, string>,
   life: number = 4,
-): Promise<IAutoBeRealizeDecoratorApplication.IProps> {
+): Promise<AutoBeRealizeAuthorization> {
   // Check Compile
   const files = {
     ...templateFiles,
     ...prismaClients,
-    [`src/decorators/${result.decorator.name}.ts`]: result.decorator.code,
-    [`src/authentications/${result.provider.name}.ts`]: result.provider.code,
-    [`src/authentications/types/${result.decoratorType.name}.ts`]:
-      result.decoratorType.code,
+    [auth.decorator.location]: auth.decorator.content,
+    [auth.payload.location]: auth.payload.content,
+    [auth.provider.location]: auth.provider.content,
   };
 
   const compiler: IAutoBeCompiler = await ctx.compiler();
-
-  const compiled = await compiler.typescript.compile({
-    files,
-  });
-
+  const result: IAutoBeTypeScriptCompileResult =
+    await compiler.typescript.compile({
+      files,
+    });
   ctx.dispatch({
-    type: "realizeDecoratorValidate",
+    type: "realizeAuthorizationValidate",
     created_at: new Date().toISOString(),
-    result: compiled,
-    files,
+    result,
+    authorization: auth,
     step: ctx.state().test?.step ?? 0,
   });
-
-  if (compiled.type === "success") {
-    return result;
-  } else if (compiled.type === "exception" || life === 0) {
-    return result;
+  if (result.type === "success") {
+    return auth;
+  } else if (result.type === "exception" || life === 0) {
+    return auth;
   }
 
   const pointer: IPointer<IAutoBeRealizeDecoratorApplication.IProps | null> = {
     value: null,
   };
-
   const agentica: MicroAgentica<Model> = new MicroAgentica({
     model: ctx.model,
     vendor: ctx.vendor,
@@ -193,9 +196,9 @@ async function correctDecorator<Model extends ILlmSchema.Model>(
     },
     histories: transformRealizeDecoratorCorrectHistories(
       ctx,
-      result,
+      auth,
       templateFiles,
-      compiled.diagnostics,
+      result.diagnostics,
     ),
     controllers: [
       createApplication({
@@ -217,27 +220,34 @@ async function correctDecorator<Model extends ILlmSchema.Model>(
 
   if (pointer.value === null) throw new Error("Failed to correct decorator.");
 
-  const correctedFiles: Record<string, string> = {
-    ...files,
-    [`src/decorators/${pointer.value.decorator.name}.ts`]:
-      pointer.value.decorator.code,
-    [`src/authentications/${pointer.value.provider.name}.ts`]:
-      pointer.value.provider.code,
-    [`src/authentications/types/${pointer.value.decoratorType.name}.ts`]:
-      pointer.value.decoratorType.code,
+  const corrected: AutoBeRealizeAuthorization = {
+    role: auth.role,
+    decorator: {
+      location: auth.decorator.location,
+      name: pointer.value.decorator.name,
+      content: pointer.value.decorator.code,
+    },
+    payload: {
+      location: auth.payload.location,
+      name: pointer.value.payload.name,
+      content: pointer.value.payload.code,
+    },
+    provider: {
+      location: auth.provider.location,
+      name: pointer.value.provider.name,
+      content: pointer.value.provider.code,
+    },
   };
-
   ctx.dispatch({
-    type: "realizeDecoratorCorrect",
+    type: "realizeAuthorizationCorrect",
     created_at: new Date().toISOString(),
-    files: correctedFiles,
-    result: compiled,
+    authorization: corrected,
+    result: result,
     step: ctx.state().test?.step ?? 0,
   });
-
   return await correctDecorator(
     ctx,
-    pointer.value,
+    corrected,
     prismaClients,
     templateFiles,
     life - 1,

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -1,7 +1,6 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import {
   AutoBeOpenApi,
-  IAutoBeCompiler,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
@@ -21,6 +20,7 @@ import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
 import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
 import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
 import { transformRealizeCoderHistories } from "./transformRealizeCoderHistories";
+import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 /**
  * Generates a TypeScript function implementation based on the given plan.
@@ -55,6 +55,7 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
   | FAILED
 > => {
   total;
+
   const artifacts: IAutoBeTestScenarioArtifacts =
     await getTestScenarioArtifacts(ctx, {
       endpoint: {
@@ -126,43 +127,21 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
 
   pointer.value.implementationCode = await replaceImportStatements(ctx)(
     pointer.value.implementationCode,
+    props.decoratorEvent?.payload.name,
   );
 
+  pointer.value.implementationCode =
+    pointer.value.implementationCode.replaceAll(
+      "typia.tags.assert",
+      "typia.assert",
+    );
+
   return {
     ...pointer.value,
     filename: `src/providers/${props.functionName}.ts`,
   };
 };
 
-function replaceImportStatements<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-) {
-  return async function (code: string) {
-    const compiler: IAutoBeCompiler = await ctx.compiler();
-    code = await compiler.typescript.beautify(code);
-    code = code
-      .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
-      .replaceAll('import typia, { tags } from "typia";', "")
-      .replaceAll('import { tags } from "typia";', "")
-      .replaceAll('import { tags, typia } from "typia";', "")
-      .replaceAll('import typia from "typia";', "")
-      .replaceAll('import { Prisma } from "@prisma/client";', "")
-      .replaceAll('import { jwtDecode } from "./jwtDecode"', "")
-      .replaceAll('import { v4 } from "uuid"', "");
-    code = [
-      'import { MyGlobal } from "../MyGlobal";',
-      'import typia, { tags } from "typia";',
-      'import { Prisma } from "@prisma/client";',
-      'import { jwtDecode } from "./jwtDecode";',
-      'import { v4 } from "uuid";',
-      "",
-      code,
-    ].join("\n");
-
-    return code;
-  };
-}
-
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: IAutoBeRealizeCoderApplication.IProps) => void;

package/src/orchestrate/realize/orchestrateRealizePlanner.ts

@@ -1,4 +1,4 @@
-import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -65,6 +65,16 @@ export interface RealizePlannerOutput {
    * conditions. Used as a basis for TDD-style automated test generation.
    */
   testScenarios: string[];
+
+  /**
+   * 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;
 }
 
 /**
@@ -89,6 +99,7 @@ export interface RealizePlannerOutput {
 export const orchestrateRealizePlanner = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operation: AutoBeOpenApi.IOperation,
+  authorization?: AutoBeRealizeAuthorization,
 ): Promise<RealizePlannerOutput> => {
   const testScenarios =
     ctx
@@ -111,5 +122,6 @@ export const orchestrateRealizePlanner = async <Model extends ILlmSchema.Model>(
       .replaceAll("-", "_")
       .replaceAll("{", "$")
       .replaceAll("}", "")}`,
+    decoratorEvent: authorization,
   } satisfies RealizePlannerOutput;
 };