@autobe/agent 0.28.0 → 0.29.0

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -1,10 +1,10 @@
 import {
+  AutoBeEventSource,
   AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeCorrectEvent,
   AutoBeRealizeFunction,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import {
   ILlmApplication,
   ILlmController,
@@ -19,13 +19,13 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { validateEmptyCode } from "../../utils/validateEmptyCode";
-import { transformRealizeCorrectHistories } from "./histories/transformRealizeCorrectHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformRealizeCorrectHistory } from "./histories/transformRealizeCorrectHistory";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCorrectApplication";
 import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { filterDiagnostics } from "./utils/filterDiagnostics";
-import { getRealizeWriteCodeTemplate } from "./utils/getRealizeWriteCodeTemplate";
 import { getRealizeWriteDto } from "./utils/getRealizeWriteDto";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
@@ -134,6 +134,7 @@ async function correct<Model extends ILlmSchema.Model>(
   }
 
   const corrected: AutoBeRealizeFunction[] = await executeCachedBatch(
+    ctx,
     props.locations.map(
       (location) => async (): Promise<AutoBeRealizeFunction> => {
         const scenario = props.scenarios.find((el) => el.location === location);
@@ -209,90 +210,84 @@ async function step<Model extends ILlmSchema.Model>(
     progress: AutoBeProgressEventBase;
   },
 ): Promise<AutoBeRealizeCorrectEvent | null> {
-  const pointer: IPointer<IAutoBeRealizeCorrectApplication.IProps | null> = {
-    value: null,
-  };
-
-  const dto = await getRealizeWriteDto(ctx, props.scenario.operation);
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "realizeCorrect",
-    controller: createController({
-      model: ctx.model,
-      functionName: props.scenario.functionName,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    histories: transformRealizeCorrectHistories({
+  const dto: Record<string, string> = await getRealizeWriteDto(
+    ctx,
+    props.scenario.operation,
+  );
+  const preliminary: AutoBePreliminaryController<"prismaSchemas"> =
+    new AutoBePreliminaryController({
+      source: SOURCE,
+      application: typia.json.application<IAutoBeRealizeCorrectApplication>(),
+      kinds: ["prismaSchemas"],
       state: ctx.state(),
-      scenario: props.scenario,
-      authorization: props.authorization,
-      dto,
-      failures: [...props.previousFailures, props.failure],
-      totalAuthorizations: props.totalAuthorizations,
-    }),
-    enforceFunctionCall: true,
-    message: StringUtil.trim`
-      Correct the TypeScript code implementation.
-
-      The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
-      When modifying, modify the entire code, but not the import statement.
-
-      Below is template code you wrote:
-
-      ${getRealizeWriteCodeTemplate({
+    });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeRealizeCorrectApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: "realizeCorrect",
+      controller: createController({
+        model: ctx.model,
+        functionName: props.scenario.functionName,
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      ...transformRealizeCorrectHistory(ctx, {
+        state: ctx.state(),
         scenario: props.scenario,
-        schemas: ctx.state().interface!.document.components.schemas,
+        authorization: props.authorization,
+        function: props.function,
+        dto,
+        failures: [...props.previousFailures, props.failure],
+        totalAuthorizations: props.totalAuthorizations,
+        preliminary,
+      }),
+    });
+    if (pointer.value !== null) {
+      pointer.value.draft = await replaceImportStatements(ctx, {
         operation: props.scenario.operation,
-        authorization: props.authorization ?? null,
-      })}
-
-      Current code is as follows:
-      \`\`\`typescript
-      ${props.function.content}
-      \`\`\`
-    `,
-  });
-
-  if (pointer.value === null) {
-    return null;
-  }
-
-  pointer.value.draft = await replaceImportStatements(ctx, {
-    operation: props.scenario.operation,
-    schemas: ctx.state().interface!.document.components.schemas,
-    code: pointer.value.draft,
-    decoratorType: props.authorization?.payload.name,
+        schemas: ctx.state().interface!.document.components.schemas,
+        code: pointer.value.draft,
+        decoratorType: props.authorization?.payload.name,
+      });
+      if (pointer.value.revise.final)
+        pointer.value.revise.final = await replaceImportStatements(ctx, {
+          operation: props.scenario.operation,
+          schemas: ctx.state().interface!.document.components.schemas,
+          code: pointer.value.revise.final,
+          decoratorType: props.authorization?.payload.name,
+        });
+
+      const event: AutoBeRealizeCorrectEvent = {
+        type: "realizeCorrect",
+        kind: "overall",
+        id: v7(),
+        location: props.scenario.location,
+        content: pointer.value.revise.final ?? pointer.value.draft,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        completed: ++props.progress.completed,
+        total: props.progress.total,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      };
+      ctx.dispatch(event);
+      return out(result)(event);
+    }
+    return out(result)(null);
   });
-  if (pointer.value.revise.final)
-    pointer.value.revise.final = await replaceImportStatements(ctx, {
-      operation: props.scenario.operation,
-      schemas: ctx.state().interface!.document.components.schemas,
-      code: pointer.value.revise.final,
-      decoratorType: props.authorization?.payload.name,
-    });
-
-  const event: AutoBeRealizeCorrectEvent = {
-    type: "realizeCorrect",
-    kind: "overall",
-    id: v7(),
-    location: props.scenario.location,
-    content: pointer.value.revise.final ?? pointer.value.draft,
-    metric,
-    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;
   functionName: string;
-  build: (next: IAutoBeRealizeCorrectApplication.IProps) => void;
+  build: (next: IAutoBeRealizeCorrectApplication.IComplete) => void;
+  preliminary: AutoBePreliminaryController<"prismaSchemas">;
 }): ILlmController<Model> {
   assertSchemaModel(props.model);
 
@@ -300,10 +295,15 @@ function createController<Model extends ILlmSchema.Model>(props: {
     const result: IValidation<IAutoBeRealizeCorrectApplication.IProps> =
       typia.validate<IAutoBeRealizeCorrectApplication.IProps>(input);
     if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
     const errors: IValidation.IError[] = validateEmptyCode({
       functionName: props.functionName,
-      draft: result.data.draft,
-      revise: result.data.revise,
+      draft: result.data.request.draft,
+      revise: result.data.request.revise,
     });
     return errors.length
       ? {
@@ -325,11 +325,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
   return {
     protocol: "class",
-    name: "Write code",
+    name: SOURCE,
     application,
     execute: {
-      correct: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBeRealizeCorrectApplication,
   };
@@ -339,19 +339,19 @@ const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeRealizeCorrectApplication, "chatgpt">({
       validate: {
-        correct: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
     typia.llm.application<IAutoBeRealizeCorrectApplication, "claude">({
       validate: {
-        correct: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
     typia.llm.application<IAutoBeRealizeCorrectApplication, "gemini">({
       validate: {
-        correct: validate,
+        process: validate,
       },
     }),
 };
@@ -359,3 +359,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeRealizeCorrectApplication.IProps>;
+
+const SOURCE = "realizeCorrect" satisfies AutoBeEventSource;

package/src/orchestrate/realize/orchestrateRealizeCorrectCasting.ts

@@ -6,7 +6,6 @@ import {
   AutoBeRealizeValidateEvent,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import {
   ILlmApplication,
   ILlmController,
@@ -22,11 +21,10 @@ import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
-import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
+import { transformRealizeCorrectCastingHistory } from "./histories/transformRealizeCorrectCastingHistory";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
-import { getRealizeWriteCodeTemplate } from "./utils/getRealizeWriteCodeTemplate";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 /** Result of attempting to correct a single function */
@@ -115,6 +113,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   props.progress.total += locations.length;
 
   const converted: CorrectionResult[] = await executeCachedBatch(
+    ctx,
     locations.map((location) => async (): Promise<CorrectionResult> => {
       const func: AutoBeRealizeFunction = props.functions.find(
         (f) => f.location === location,
@@ -135,7 +134,21 @@ const correct = async <Model extends ILlmSchema.Model>(
       };
       const { metric, tokenUsage } = await ctx.conversate({
         source: "realizeCorrect",
-        histories: transformRealizeCorrectCastingHistories({
+        controller: createController({
+          model: ctx.model,
+          functionName: scenario.functionName,
+          then: (next) => {
+            pointer.value = next;
+          },
+          reject: () => {
+            pointer.value = false;
+          },
+        }),
+        enforceFunctionCall: true,
+        ...transformRealizeCorrectCastingHistory(ctx, {
+          scenario,
+          authorization,
+          function: func,
           failures: [
             ...props.previousFailures
               .map(
@@ -151,58 +164,6 @@ const correct = async <Model extends ILlmSchema.Model>(
             },
           ],
         }),
-        controller: createController({
-          model: ctx.model,
-          functionName: scenario.functionName,
-          then: (next) => {
-            pointer.value = next;
-          },
-          reject: () => {
-            pointer.value = false;
-          },
-        }),
-        enforceFunctionCall: true,
-        message: StringUtil.trim`
-          Fix the TypeScript casting problems to resolve the compilation error.
-
-          Most casting errors are caused by type mismatches between Date types and
-          string & tags.Format<'date-time'>. To fix these:
-          - Use ONLY the pre-provided toISOStringSafe() function to convert Date to string
-          - Do NOT use .toISOString() method directly (use toISOStringSafe instead)
-          - Never use Date type directly in declarations or return values
-
-          You don't need to explain me anything, but just fix or give it up
-          immediately without any hesitation, explanation, and questions.
-
-          The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
-          When modifying, modify the entire code, but not the import statement.
-
-          Below is template code you wrote:
-
-          ${getRealizeWriteCodeTemplate({
-            scenario,
-            schemas: ctx.state().interface!.document.components.schemas,
-            operation: scenario.operation,
-            authorization: authorization ?? null,
-          })}
-
-          Current code is as follows:
-
-          \`\`\`typescript
-          ${func.content}
-          \`\`\`
-
-          Also, never use typia.assert and typia.assertGuard like functions
-          to the Prisma types. Your mission is to fix the casting problem of
-          primitive types like string or number. Prisma type is not your scope.
-
-          If you take a mistake that casting the Prisma type with the typia.assert
-          function, it would be fallen into the infinite compilation due to extremely
-          complicated Prisma type. Note that, the typia.assert function is allowed
-          only in the individual property level string or literal type.
-
-          I repeat that, never assert the Prisma type. It's not your mission.
-        `,
       });
       ++props.progress.completed;
 

package/src/orchestrate/realize/orchestrateRealizeWrite.ts

@@ -1,10 +1,10 @@
 import {
+  AutoBeEventSource,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeWriteEvent,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import {
   ILlmApplication,
   ILlmController,
@@ -18,6 +18,7 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { validateEmptyCode } from "../../utils/validateEmptyCode";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
 import { transformRealizeWriteHistories } from "./histories/transformRealizeWriteHistories";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { IAutoBeRealizeWriteApplication } from "./structures/IAutoBeRealizeWriteApplication";
@@ -35,83 +36,81 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
     promptCacheKey: string;
   },
 ): Promise<AutoBeRealizeWriteEvent> {
-  const pointer: IPointer<IAutoBeRealizeWriteApplication.IProps | null> = {
-    value: null,
-  };
-
-  const dto = await getRealizeWriteDto(ctx, props.scenario.operation);
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "realizeWrite",
-    histories: transformRealizeWriteHistories({
+  const preliminary: AutoBePreliminaryController<"prismaSchemas"> =
+    new AutoBePreliminaryController({
+      source: SOURCE,
+      application: typia.json.application<IAutoBeRealizeWriteApplication>(),
+      kinds: ["prismaSchemas"],
       state: ctx.state(),
-      scenario: props.scenario,
-      authorization: props.authorization,
-      totalAuthorizations: props.totalAuthorizations,
-      dto,
-    }),
-    controller: createController({
-      model: ctx.model,
-      functionName: props.scenario.functionName,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: StringUtil.trim`
-      Write complete, production-ready TypeScript code that strictly follows these rules:
-
-      DO NOT:
-      - Use the native \`Date\` type anywhere
-      - Use \`as\` for type assertions
-
-      DO:
-      - Write all date/datetime values as \`string & tags.Format<'date-time'>\`
-      - Generate UUIDs using \`v4()\` and type as \`string & tags.Format<'uuid'>\`
-      - Resolve types properly without assertions
-      - Type all functions with clear parameter and return types
-      6. Do not skip validations or default values where necessary.
-      7. Follow functional, immutable, and consistent code structure.
-
-      Use \`@nestia/e2e\` test structure if relevant.
-    `,
-  });
-  if (pointer.value === null) throw new Error("Failed to write code.");
-
-  pointer.value.draft = await replaceImportStatements(ctx, {
-    operation: props.scenario.operation,
-    schemas: props.document.components.schemas,
-    code: pointer.value.draft,
-    decoratorType: props.authorization?.payload.name,
-  });
-  if (pointer.value.revise.final)
-    pointer.value.revise.final = await replaceImportStatements(ctx, {
-      operation: props.scenario.operation,
-      schemas: props.document.components.schemas,
-      code: pointer.value.revise.final,
-      decoratorType: props.authorization?.payload.name,
     });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeRealizeWriteApplication.IComplete | null> = {
+      value: null,
+    };
+    const dto: Record<string, string> = await getRealizeWriteDto(
+      ctx,
+      props.scenario.operation,
+    );
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: "realizeWrite",
+      controller: createController({
+        model: ctx.model,
+        functionName: props.scenario.functionName,
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformRealizeWriteHistories({
+        state: ctx.state(),
+        scenario: props.scenario,
+        authorization: props.authorization,
+        totalAuthorizations: props.totalAuthorizations,
+        dto,
+        preliminary,
+      }),
+    });
+    if (pointer.value !== null) {
+      pointer.value.draft = await replaceImportStatements(ctx, {
+        operation: props.scenario.operation,
+        schemas: props.document.components.schemas,
+        code: pointer.value.draft,
+        decoratorType: props.authorization?.payload.name,
+      });
+      if (pointer.value.revise.final)
+        pointer.value.revise.final = await replaceImportStatements(ctx, {
+          operation: props.scenario.operation,
+          schemas: props.document.components.schemas,
+          code: pointer.value.revise.final,
+          decoratorType: props.authorization?.payload.name,
+        });
 
-  const event: AutoBeRealizeWriteEvent = {
-    type: "realizeWrite",
-    id: v7(),
-    location: props.scenario.location,
-    content: pointer.value.revise.final ?? pointer.value.draft,
-    metric,
-    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;
+      const event: AutoBeRealizeWriteEvent = {
+        type: "realizeWrite",
+        id: v7(),
+        location: props.scenario.location,
+        content: pointer.value.revise.final ?? pointer.value.draft,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        completed: ++props.progress.completed,
+        total: props.progress.total,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      };
+      ctx.dispatch(event);
+      return out(result)(event);
+    }
+    return out(result)(null);
+  });
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   functionName: string;
-  build: (next: IAutoBeRealizeWriteApplication.IProps) => void;
+  build: (next: IAutoBeRealizeWriteApplication.IComplete) => void;
+  preliminary: AutoBePreliminaryController<"prismaSchemas">;
 }): ILlmController<Model> {
   assertSchemaModel(props.model);
 
@@ -119,10 +118,13 @@ function createController<Model extends ILlmSchema.Model>(props: {
     const result: IValidation<IAutoBeRealizeWriteApplication.IProps> =
       typia.validate<IAutoBeRealizeWriteApplication.IProps>(input);
     if (result.success === false) return result;
+    else if (result.data.request.type !== "complete") {
+      return result;
+    }
     const errors: IValidation.IError[] = validateEmptyCode({
       functionName: props.functionName,
-      draft: result.data.draft,
-      revise: result.data.revise,
+      draft: result.data.request.draft,
+      revise: result.data.request.revise,
     });
     return errors.length
       ? {
@@ -144,11 +146,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
   return {
     protocol: "class",
-    name: "Write code",
+    name: SOURCE,
     application,
     execute: {
-      write: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBeRealizeWriteApplication,
   };
@@ -158,19 +160,19 @@ const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeRealizeWriteApplication, "chatgpt">({
       validate: {
-        write: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
     typia.llm.application<IAutoBeRealizeWriteApplication, "claude">({
       validate: {
-        write: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
     typia.llm.application<IAutoBeRealizeWriteApplication, "gemini">({
       validate: {
-        write: validate,
+        process: validate,
       },
     }),
 };
@@ -178,3 +180,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeRealizeWriteApplication.IProps>;
+
+const SOURCE = "realizeWrite" satisfies AutoBeEventSource;