@autobe/agent 0.17.1 → 0.19.1

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -4,47 +4,157 @@ 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 { predicateStateMessage } from "../../utils/predicateStateMessage";
+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>) =>
   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: v4(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
     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
+    // AUTHORIZATIONS
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
-    const result = await writeCodeUntilCompilePassed(ctx)({
-      operations,
-      authorizations,
-      retry: 4,
+
+    // SCENARIOS
+    const scenarios: IAutoBeRealizeScenarioApplication.IProps[] =
+      operations.map((operation) => {
+        const authorization = authorizations.find(
+          (el) => el.role.name === operation.authorizationRole,
+        );
+
+        return orchestrateRealizeScenario(ctx, operation, authorization);
+      });
+
+    const writeProgress = { total: scenarios.length, completed: 0 };
+    const writeEvents: AutoBeRealizeWriteEvent[] = await Promise.all(
+      scenarios.map(async (scenario) => {
+        const code = orchestrateRealizeWrite(ctx, {
+          totalAuthorizations: authorizations,
+          authorization: scenario.decoratorEvent ?? null,
+          scenario,
+          progress: writeProgress,
+        });
+        return code;
+      }),
+    );
+
+    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,
+      };
     });
 
-    const functions: AutoBeRealizeFunction[] = result.functions;
+    let compilation = await compile(ctx, { authorizations, functions });
+
+    if (compilation.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 (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 Promise.all(
+            Object.entries(failedFiles).map(async ([location, content]) => {
+              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 compile(ctx, { authorizations, functions });
+          if (compilation.type === "success") {
+            break;
+          }
+        }
+      }
+    }
 
-    // compile controllers
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
@@ -53,29 +163,14 @@ export const orchestrateRealize =
         authorizations,
       });
 
-    // report
     return ctx.dispatch({
       type: "realizeComplete",
       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 compile(ctx, { authorizations, functions }),
       step: ctx.state().analyze?.step ?? 0,
+      elapsed: new Date().getTime() - start.getTime(),
     });
   };

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,
+  AutoBeProgressEventBase,
+  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 { 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: AutoBeProgressEventBase = {
+    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: AutoBeProgressEventBase,
 ): 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().aggregate;
-      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().aggregate;
-      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,122 @@
+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/IAutoBeRealizeCorrectApplication";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+import { replaceImportStatements } from "./utils/replaceImportStatements";
+
+export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    authorization: AutoBeRealizeAuthorization | null;
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    code: string;
+    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+    progress: IProgress;
+  },
+): Promise<AutoBeRealizeCorrectEvent> {
+  const artifacts: IAutoBeTestScenarioArtifacts =
+    await getTestScenarioArtifacts(ctx, {
+      endpoint: props.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: props.scenario,
+      artifacts,
+      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"),
+  });
+
+  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,
+  );
+
+  const event: AutoBeRealizeCorrectEvent = {
+    type: "realizeCorrect",
+    location: props.scenario.location,
+    content: pointer.value.implementationCode,
+    tokenUsage,
+    completed: ++props.progress.completed,
+    total: props.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;
+}