@autobe/agent 0.18.0 → 0.20.0

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -1,6 +1,7 @@
 import {
   AutoBeAssistantMessageHistory,
   AutoBeOpenApi,
+  AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeFunction,
   AutoBeRealizeHistory,
@@ -9,12 +10,13 @@ import {
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
+import { v7 } 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 { 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";
@@ -26,116 +28,152 @@ export const orchestrateRealize =
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
+    // PREDICATION
     const operations: AutoBeOpenApi.IOperation[] | undefined =
       ctx.state().interface?.document.operations;
-    if (!operations) {
+    if (!operations)
       throw new Error("Can't do realize agent because operations are nothing.");
-    }
 
     const start: Date = new Date();
+    const predicate: string | null = predicateStateMessage(
+      ctx.state(),
+      "realize",
+    );
+    if (predicate !== null)
+      return ctx.assistantMessage({
+        type: "assistantMessage",
+        id: v7(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
     ctx.dispatch({
       type: "realizeStart",
+      id: v7(),
       created_at: start.toISOString(),
       reason: props.reason,
       step: ctx.state().test?.step ?? 0,
     });
 
+    // AUTHORIZATIONS
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
 
+    // SCENARIOS
     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,
+      operations.map((operation) => {
+        const authorization = authorizations.find(
+          (el) => el.role.name === operation.authorizationRole,
         );
+
+        return orchestrateRealizeScenario(ctx, operation, authorization);
+      });
+
+    const writeProgress: AutoBeProgressEventBase = {
+      total: scenarios.length,
+      completed: 0,
+    };
+    const writeEvents: AutoBeRealizeWriteEvent[] = await executeCachedBatch(
+      scenarios.map((scenario) => async (promptCacheKey) => {
+        const code = await orchestrateRealizeWrite(ctx, {
+          totalAuthorizations: authorizations,
+          authorization: scenario.decoratorEvent ?? null,
+          scenario,
+          progress: writeProgress,
+          promptCacheKey,
+        });
         return code;
       }),
     );
 
-    let providers = Object.fromEntries(
-      writeEvents.map((event) => [event.location, event.content]),
-    );
+    const functions: AutoBeRealizeFunction[] = Object.entries(
+      Object.fromEntries(
+        writeEvents.map((event) => [event.location, event.content]),
+      ),
+    ).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,
+      };
+    });
 
-    let finalCompilationResult = await compile(ctx, {
+    let compilation = await compileRealizeFiles(ctx, {
       authorizations,
-      providers,
+      functions,
     });
 
-    if (finalCompilationResult.type !== "success") {
-      const MAX_CORRECTION_ATTEMPTS = 3 as const;
+    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 (finalCompilationResult.result.type === "failure") {
-          const failedFiles: Record<string, string> =
-            finalCompilationResult.files;
+        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 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;
-              }
-            }),
+          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;
+                    }
+                  }
+                },
+            ),
           );
 
-          finalCompilationResult = await compile(ctx, {
+          compilation = await compileRealizeFiles(ctx, {
             authorizations,
-            providers,
+            functions,
           });
-
-          if (finalCompilationResult.type === "success") {
+          if (compilation.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,
-        };
-      },
-    );
-
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
@@ -143,29 +181,14 @@ export const orchestrateRealize =
         functions,
         authorizations,
       });
-
     return ctx.dispatch({
       type: "realizeComplete",
+      id: v7(),
       created_at: new Date().toISOString(),
       functions,
       authorizations,
       controllers,
-      compiled: await compiler.typescript.compile({
-        files: {
-          ...(await getAutoBeGenerated(
-            compiler,
-            ctx.state(),
-            ctx.histories(),
-            ctx.usage(),
-          )),
-          ...(await getAutoBeRealizeGenerated({
-            document: ctx.state().interface!.document,
-            authorizations,
-            functions,
-            compiler,
-          })),
-        },
-      }),
+      compiled: await compileRealizeFiles(ctx, { authorizations, functions }),
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -1,6 +1,7 @@
 import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeAnalyzeRole,
+  AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeAuthorizationWriteEvent,
   IAutoBeCompiler,
@@ -8,10 +9,11 @@ import {
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { IProgress } from "../internal/IProgress";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformRealizeAuthorizationHistories } from "./histories/transformRealizeAuthorization";
 import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
 import { IAutoBeRealizeAuthorizationApplication } from "./structures/IAutoBeRealizeAuthorizationApplication";
@@ -29,30 +31,34 @@ export async function orchestrateRealizeAuthorization<
 >(ctx: AutoBeContext<Model>): Promise<AutoBeRealizeAuthorization[]> {
   ctx.dispatch({
     type: "realizeAuthorizationStart",
+    id: v7(),
     step: ctx.state().test?.step ?? 0,
     created_at: new Date().toISOString(),
   });
 
   const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: roles.length,
     completed: 0,
   };
   const templateFiles = await (await ctx.compiler()).realize.getTemplate();
-  const authorizations: AutoBeRealizeAuthorization[] = await Promise.all(
-    roles.map((role) =>
-      process(
-        ctx,
-        role,
-        InternalFileSystem.DEFAULT.map((el) => ({
-          [el]: templateFiles[el],
-        })).reduce((acc, cur) => Object.assign(acc, cur), {}),
-        progress,
-      ),
+  const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
+    roles.map(
+      (role) => (promptCacheKey) =>
+        process(
+          ctx,
+          role,
+          InternalFileSystem.DEFAULT.map((el) => ({
+            [el]: templateFiles[el],
+          })).reduce((acc, cur) => Object.assign(acc, cur), {}),
+          progress,
+          promptCacheKey,
+        ),
     ),
   );
   ctx.dispatch({
     type: "realizeAuthorizationComplete",
+    id: v7(),
     created_at: new Date().toISOString(),
     step: ctx.state().test?.step ?? 0,
   });
@@ -63,7 +69,8 @@ async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   role: AutoBeAnalyzeRole,
   templateFiles: Record<string, string>,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
+  promptCacheKey: string,
 ): Promise<AutoBeRealizeAuthorization> {
   const pointer: IPointer<IAutoBeRealizeAuthorizationApplication.IProps | null> =
     {
@@ -79,6 +86,7 @@ async function process<Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
+    promptCacheKey,
     message: "Create Authorization Provider and Decorator.",
   });
   if (pointer.value === null) throw new Error("Failed to create decorator.");
@@ -114,6 +122,7 @@ async function process<Model extends ILlmSchema.Model>(
 
   ctx.dispatch({
     type: "realizeAuthorizationWrite",
+    id: v7(),
     created_at: new Date().toISOString(),
     authorization: authorization,
     tokenUsage,

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -8,6 +8,7 @@ import {
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
@@ -58,6 +59,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
 
   ctx.dispatch({
     type: "realizeAuthorizationValidate",
+    id: v7(),
     created_at: new Date().toISOString(),
     authorization: authorization,
     result: compiled,
@@ -120,6 +122,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
   ctx.dispatch({
     ...pointer.value,
     type: "realizeAuthorizationCorrect",
+    id: v7(),
     created_at: new Date().toISOString(),
     authorization: result,
     result: compiled,

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -1,32 +1,38 @@
 import {
+  AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeCorrectEvent,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
+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 { transformRealizeCorrectHistories } from "./histories/transformRealizeCorrectHistories";
-import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeReviewApplication";
+import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCorrectApplication";
 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,
+  props: {
+    authorization: AutoBeRealizeAuthorization | null;
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    code: string;
+    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+    progress: AutoBeProgressEventBase;
+  },
 ): Promise<AutoBeRealizeCorrectEvent> {
   const artifacts: IAutoBeTestScenarioArtifacts =
     await getTestScenarioArtifacts(ctx, {
-      endpoint: scenario.operation,
+      endpoint: props.scenario.operation,
       dependencies: [],
     });
 
@@ -43,17 +49,19 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     }),
     histories: transformRealizeCorrectHistories({
       state: ctx.state(),
-      scenario,
+      scenario: props.scenario,
       artifacts,
-      authorization,
-      code,
-      diagnostic,
+      authorization: props.authorization,
+      code: props.code,
+      diagnostic: props.diagnostic,
+      totalAuthorizations: props.totalAuthorizations,
     }),
     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"),
+    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.
+    `,
   });
 
   if (pointer.value === null)
@@ -62,16 +70,17 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   pointer.value.implementationCode = await replaceImportStatements(ctx)(
     artifacts,
     pointer.value.implementationCode,
-    authorization?.payload.name,
+    props.authorization?.payload.name,
   );
 
   const event: AutoBeRealizeCorrectEvent = {
     type: "realizeCorrect",
-    location: scenario.location,
+    id: v7(),
+    location: props.scenario.location,
     content: pointer.value.implementationCode,
     tokenUsage,
-    completed: ++progress.completed,
-    total: progress.total,
+    completed: ++props.progress.completed,
+    total: props.progress.total,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };
@@ -111,8 +120,3 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
-
-export interface IProgress {
-  total: number;
-  completed: number;
-}

package/src/orchestrate/realize/orchestrateRealizeScenario.ts

@@ -4,80 +4,6 @@ import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
 
-export interface IAutoBeRealizeScenario {
-  /**
-   * 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;
-
-  /**
-   * Definition of path and query parameters extracted from the OpenAPI spec.
-   *
-   * Includes input values passed via URL path or query string. Used for type
-   * definitions, validation, and function signature construction.
-   */
-  parameters: AutoBeOpenApi.IParameter[];
-
-  /**
-   * Schema definition for the request body input.
-   *
-   * Extracted from the requestBody section of Swagger. Represents the input
-   * data passed in the body (e.g., JSON). Used for generating function
-   * arguments or DTOs.
-   */
-  inputSchema: AutoBeOpenApi.IRequestBody | null;
-
-  /**
-   * Schema definition for the response body.
-   *
-   * Extracted from the responses section of Swagger. Used to define the return
-   * type and expected output in test code.
-   */
-  outputSchema: AutoBeOpenApi.IResponseBody | null;
-
-  /**
-   * Natural language description of the function’s purpose.
-   *
-   * Extracted from the summary or description field of Swagger. Used for code
-   * documentation, test scenario generation, and conveying function intent.
-   */
-  description: string;
-
-  /**
-   * HTTP method information.
-   *
-   * Extracted from the Swagger operation method. Used to define the request
-   * type during code and test generation.
-   */
-  method: "get" | "post" | "put" | "delete" | "patch";
-
-  /**
-   * 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.
-   */
-  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;
-}
-
 /**
  * Generates a planning result that defines what kind of function should be
  * created, based solely on the provided Swagger (OpenAPI) operation — without