@autobe/agent 0.25.0 → 0.25.1

package/src/orchestrate/realize/histories/transformRealizeCorrectCastingHistories.ts

@@ -4,6 +4,7 @@ import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { printErrorHints } from "../utils/printErrorHints";
 
 interface IFailure {
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
@@ -20,23 +21,21 @@ export const transformRealizeCorrectCastingHistories = (
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CORRECT_CASTING,
+      text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
     },
     ...failures.map(
-      (f, i, array) =>
+      (f) =>
         ({
           id: v7(),
           created_at: new Date().toISOString(),
           type: "assistantMessage",
           text: StringUtil.trim`
-          # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
-          ## Generated TypeScript Code
-          \`\`\`typescript
-          ${f.script}
-          \`\`\`
-          ## Compile Errors
-          \`\`\`json
-          ${JSON.stringify(f.diagnostics)}
+          # Errors
+
+          This is a past code and an error with the code. 
+          Please refer to the annotation for the location of the error.
+
+          ${printErrorHints(f.script, f.diagnostics)}          
           \`\`\`
         `,
         }) satisfies IAgenticaHistoryJson.IAssistantMessage,

package/src/orchestrate/realize/histories/transformRealizeCorrectHistories.ts

@@ -7,6 +7,7 @@ import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromp
 import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { printErrorHints } from "../utils/printErrorHints";
 import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
 
 export function transformRealizeCorrectHistories(props: {
@@ -40,30 +41,18 @@ export function transformRealizeCorrectHistories(props: {
       `,
       created_at: new Date().toISOString(),
     },
-    ...props.failures.map(
-      (f) =>
-        ({
-          id: v7(),
-          type: "assistantMessage",
-          text: StringUtil.trim`
-
-      ## Generated Typescript Code
-
-      \`\`\`typescript
-      ${f.function.content}
-      \`\`\`
-
-      ## Compile Errors
-
-      Fix the comilation error in the provided code.
-
-      \`\`\`typescript
-      ${JSON.stringify(f.diagnostics)}
-      \`\`\`
-      `,
-          created_at: new Date().toISOString(),
-        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
-    ),
+    ...props.failures.map((f) => {
+      return {
+        id: v7(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+            This is a past code and an error with the code. Please refer to the annotation for the location of the error.
+
+            ${printErrorHints(f.function.content, f.diagnostics)}
+          `,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.IAssistantMessage;
+    }),
     {
       id: v7(),
       type: "systemMessage",

package/src/orchestrate/realize/histories/transformRealizeWriteAuthorizationsHistories.ts

@@ -29,13 +29,13 @@ export const transformRealizeWriteAuthorizationsHistories = (
               - Must NOT require authentication decorator (this endpoint creates authentication)
               - Should check if user exists and password matches
 
-              ### MANDATORY: Use MyGlobal.password for Password Verification
+              ### MANDATORY: Use PasswordUtil for Password Verification
               
-              **CRITICAL**: You MUST use MyGlobal.password utilities for password verification to ensure consistency with the join operation:
+              **CRITICAL**: You MUST use PasswordUtil utilities for password verification to ensure consistency with the join operation:
 
               \`\`\`typescript
               // Example: Password verification in login
-              const isValid = await MyGlobal.password.verify(
+              const isValid = await PasswordUtil.verify(
                 body.password,           // plain password from request
                 user.password_hash       // hashed password from database
               );
@@ -126,13 +126,13 @@ export const transformRealizeWriteAuthorizationsHistories = (
               - Should create a new user record in the database
               - Must NOT require authentication decorator (public endpoint)
 
-              ### MANDATORY: Use MyGlobal.password for Password Hashing
+              ### MANDATORY: Use PasswordUtil for Password Hashing
               
-              **CRITICAL**: You MUST use MyGlobal.password utilities for password hashing to ensure consistency across all authentication operations:
+              **CRITICAL**: You MUST use PasswordUtil utilities for password hashing to ensure consistency across all authentication operations:
 
               \`\`\`typescript
               // Example: Password hashing in join/registration
-              const hashedPassword = await MyGlobal.password.hash(body.password);
+              const hashedPassword = await PasswordUtil.hash(body.password);
               
               // Store the hashed password in database
               await MyGlobal.prisma.users.create({

package/src/orchestrate/realize/histories/transformRealizeWriteHistories.ts

@@ -100,6 +100,7 @@ export const transformRealizeWriteHistories = (props: {
   const authorizationHistories = operation.authorizationType
     ? transformRealizeWriteAuthorizationsHistories(operation, payloads)
     : [];
+  const document = props.state.interface.document;
 
   return [
     {
@@ -127,11 +128,12 @@ export const transformRealizeWriteHistories = (props: {
       id: v7(),
       type: "systemMessage",
       created_at: new Date().toISOString(),
-      text: getRealizeWriteCodeTemplate(
-        props.scenario,
+      text: getRealizeWriteCodeTemplate({
+        authorization: props.authorization,
+        scenario: props.scenario,
+        schemas: document.components.schemas,
         operation,
-        props.authorization,
-      ),
+      }),
     },
     {
       id: v7(),

package/src/orchestrate/realize/internal/compileRealizeFiles.ts

@@ -47,13 +47,11 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
       props.functions.map((el) => [el.location, el.content]),
     ),
   };
-
   const compiled: IAutoBeTypeScriptCompileResult =
     await compiler.typescript.compile({
       files: files,
     });
-
-  const event: AutoBeRealizeValidateEvent = {
+  return {
     type: "realizeValidate",
     id: v7(),
     files: files,
@@ -61,6 +59,4 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };
-
-  return event;
 }

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -17,6 +17,9 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
 import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteCodeTemplate } from "./utils/getRealizeWriteCodeTemplate";
+import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 /** Result of attempting to correct a single function */
 type CorrectionResult = {
@@ -28,6 +31,7 @@ export const orchestrateRealizeCorrectCasting = async <
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   progress: AutoBeProgressEventBase,
@@ -40,9 +44,9 @@ export const orchestrateRealizeCorrectCasting = async <
       functions,
     },
   );
-
   return predicate(
     ctx,
+    scenarios,
     authorizations,
     functions,
     [],
@@ -54,6 +58,7 @@ export const orchestrateRealizeCorrectCasting = async <
 
 const predicate = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -63,9 +68,9 @@ const predicate = async <Model extends ILlmSchema.Model>(
 ): Promise<AutoBeRealizeFunction[]> => {
   if (event.result.type === "failure") {
     ctx.dispatch(event);
-
     return await correct(
       ctx,
+      scenarios,
       authorizations,
       functions,
       [...failures, ...event.result.diagnostics],
@@ -79,6 +84,7 @@ const predicate = async <Model extends ILlmSchema.Model>(
 
 const correct = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -94,12 +100,12 @@ const correct = async <Model extends ILlmSchema.Model>(
   const locations: string[] = diagnose(event).filter((l) =>
     functions.map((f) => f.location).includes(l),
   );
-  
+
   // If no locations to correct, return original functions
   if (locations.length === 0) {
     return functions;
   }
-  
+
   progress.total += locations.length;
 
   const converted: CorrectionResult[] = await executeCachedBatch(
@@ -108,6 +114,13 @@ const correct = async <Model extends ILlmSchema.Model>(
         (f) => f.location === location,
       )!;
 
+      const scenario = scenarios.find((s) => s.location === func.location)!;
+
+      const operation = scenario.operation;
+      const authorization = authorizations.find(
+        (a) => a.role.name === operation.authorizationRole,
+      );
+
       const pointer: IPointer<
         IAutoBeCommonCorrectCastingApplication.IProps | false | null
       > = {
@@ -143,18 +156,62 @@ const correct = async <Model extends ILlmSchema.Model>(
 
           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.
         `,
       });
       ++progress.completed;
+
       if (pointer.value === null)
         return { result: "exception" as const, func: func };
       else if (pointer.value === false)
         return { result: "ignore" as const, func: func };
 
+      pointer.value.draft = await replaceImportStatements(ctx, {
+        schemas: ctx.state().interface!.document.components.schemas,
+        operation: operation,
+        code: pointer.value.draft,
+        decoratorType: authorization?.payload.name,
+      });
+      if (pointer.value.revise.final)
+        pointer.value.revise.final = await replaceImportStatements(ctx, {
+          schemas: ctx.state().interface!.document.components.schemas,
+          operation: operation,
+          code: pointer.value.revise.final,
+          decoratorType: authorization?.payload.name,
+        });
+
       ctx.dispatch({
         id: v7(),
         type: "realizeCorrect",
-        content: pointer.value.revise.final,
+        content: pointer.value.revise.final ?? pointer.value.draft,
         created_at: new Date().toISOString(),
         location: func.location,
         step: ctx.state().analyze?.step ?? 0,
@@ -162,25 +219,38 @@ const correct = async <Model extends ILlmSchema.Model>(
         completed: progress.completed,
         total: progress.total,
       });
-
       return {
         result: "success" as const,
-        func: { ...func, content: pointer.value.revise.final },
+        func: {
+          ...func,
+          content: pointer.value.revise.final ?? pointer.value.draft,
+        },
       };
     }),
   );
 
+  // Get functions that were not modified (not in locations array)
+  const unchangedFunctions: AutoBeRealizeFunction[] = functions.filter(
+    (f) => !locations.includes(f.location),
+  );
+
+  // Merge converted functions with unchanged functions for validation
+  const allFunctionsForValidation = [
+    ...converted.map((c) => c.func),
+    ...unchangedFunctions,
+  ];
+
   const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
     ctx,
     {
       authorizations,
-      functions: converted.map((c) => c.func),
+      functions: allFunctionsForValidation,
     },
   );
 
   const newResult: IAutoBeTypeScriptCompileResult = newValidate.result;
   if (newResult.type === "success") {
-    return converted.map((c) => c.func);
+    return allFunctionsForValidation;
   } else if (newResult.type === "exception") {
     // Compilation exception, return current functions. because retrying won't help.
     return functions;
@@ -190,7 +260,7 @@ const correct = async <Model extends ILlmSchema.Model>(
     newResult.diagnostics.every((d) => !d.file?.startsWith("src/providers"))
   ) {
     // No diagnostics related to provider functions, stop correcting
-    return converted.map((c) => c.func);
+    return allFunctionsForValidation;
   }
 
   const newLocations: string[] = diagnose(newValidate);
@@ -201,9 +271,9 @@ const correct = async <Model extends ILlmSchema.Model>(
     newLocations,
   );
 
-  // If no failures to retry, return success and ignored functions
+  // If no failures to retry, return all functions
   if (failed.length === 0) {
-    return [...success, ...ignored];
+    return [...success, ...ignored, ...unchangedFunctions];
   }
 
   // Collect diagnostics relevant to failed functions
@@ -218,6 +288,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   // Recursively retry failed functions
   const retriedFunctions: AutoBeRealizeFunction[] = await predicate(
     ctx,
+    scenarios,
     authorizations,
     failed,
     relevantDiagnostics,
@@ -226,11 +297,7 @@ const correct = async <Model extends ILlmSchema.Model>(
     life - 1,
   );
 
-  // Get functions that were not modified (not in converted array)
-  const convertedLocations = converted.map(c => c.func.location);
-  const unchanged = functions.filter(f => !convertedLocations.includes(f.location));
-
-  return [...success, ...ignored, ...retriedFunctions, ...unchanged];
+  return [...success, ...ignored, ...retriedFunctions, ...unchangedFunctions];
 };
 
 /**

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -5,6 +5,7 @@ import {
   AutoBeRealizeAuthorization,
   AutoBeRealizeFunction,
   AutoBeRealizeHistory,
+  AutoBeRealizeValidateEvent,
   AutoBeRealizeWriteEvent,
   IAutoBeCompiler,
 } from "@autobe/interface";
@@ -29,9 +30,9 @@ export const orchestrateRealize =
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
     // PREDICATION
-    const operations: AutoBeOpenApi.IOperation[] | undefined =
-      ctx.state().interface?.document.operations;
-    if (!operations)
+    const document: AutoBeOpenApi.IDocument | undefined =
+      ctx.state().interface?.document;
+    if (document === undefined)
       throw new Error("Can't do realize agent because operations are nothing.");
 
     const start: Date = new Date();
@@ -55,102 +56,152 @@ export const orchestrateRealize =
       step: ctx.state().test?.step ?? 0,
     });
 
-    // AUTHORIZATIONS
+    // PREPARE ASSETS
+    const compiler: IAutoBeCompiler = await ctx.compiler();
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
 
-    // SCENARIOS
-    const scenarios: IAutoBeRealizeScenarioResult[] = operations.map(
-      (operation) => generateRealizeScenario(ctx, operation, authorizations),
-    );
-
     const writeProgress: AutoBeProgressEventBase = {
-      total: scenarios.length,
+      total: document.operations.length,
+      completed: 0,
+    };
+    const correctProgress: AutoBeProgressEventBase = {
+      total: document.operations.length,
       completed: 0,
     };
-    const writeEvents: (AutoBeRealizeWriteEvent | null)[] =
-      await executeCachedBatch(
-        scenarios.map((scenario) => async (promptCacheKey) => {
-          const props = {
-            totalAuthorizations: authorizations,
-            authorization: scenario.decoratorEvent ?? null,
-            scenario,
-            progress: writeProgress,
-            promptCacheKey,
-          };
-
-          const code: AutoBeRealizeWriteEvent | null =
-            await orchestrateRealizeWrite(ctx, props).catch(() => {
-              return orchestrateRealizeWrite(ctx, props).catch(() => null);
-            });
 
-          return code;
-        }),
+    const process = async (
+      artifacts: IAutoBeRealizeScenarioResult[],
+    ): Promise<IBucket> => {
+      const writes: AutoBeRealizeWriteEvent[] = (
+        await executeCachedBatch(
+          artifacts.map((art) => async (promptCacheKey) => {
+            const props = {
+              totalAuthorizations: authorizations,
+              authorization: art.decoratorEvent ?? null,
+              scenario: art,
+              document,
+              progress: writeProgress,
+              promptCacheKey,
+            };
+            try {
+              return await orchestrateRealizeWrite(ctx, props);
+            } catch {
+              try {
+                return await orchestrateRealizeWrite(ctx, props);
+              } catch {
+                return null;
+              }
+            }
+          }),
+        )
+      ).filter((w) => w !== null);
+      const functions: AutoBeRealizeFunction[] = Object.entries(
+        Object.fromEntries(writes.map((w) => [w.location, w.content])),
+      ).map(([location, content]) => {
+        const scenario: IAutoBeRealizeScenarioResult = artifacts.find(
+          (el) => el.location === location,
+        )!;
+        return {
+          location,
+          content,
+          endpoint: {
+            method: scenario.operation.method,
+            path: scenario.operation.path,
+          },
+          name: scenario.functionName,
+        };
+      });
+      const corrected: AutoBeRealizeFunction[] =
+        await orchestrateRealizeCorrectCasting(
+          ctx,
+          artifacts,
+          authorizations,
+          functions,
+          correctProgress,
+        ).then(async (res) => {
+          return await orchestrateRealizeCorrect(
+            ctx,
+            artifacts,
+            authorizations,
+            res,
+            [],
+            correctProgress,
+          );
+        });
+      const validate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
+        ctx,
+        {
+          authorizations,
+          functions: corrected,
+        },
       );
-
-    const functions: AutoBeRealizeFunction[] = Object.entries(
-      Object.fromEntries(
-        writeEvents
-          .filter((w) => w !== null)
-          .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,
+        corrected,
+        validate,
       };
-    });
-
-    const reviewProgress: AutoBeProgressEventBase = {
-      total: writeEvents.length,
-      completed: writeEvents.length,
     };
 
-    const totalCorrected: AutoBeRealizeFunction[] =
-      await orchestrateRealizeCorrectCasting(
-        ctx,
-        authorizations,
-        functions,
-        reviewProgress,
-      ).then(async (res) => {
-        return orchestrateRealizeCorrect(
-          ctx,
-          scenarios,
-          authorizations,
-          res,
-          [],
-          reviewProgress,
-        );
-      });
+    // SCENARIOS
+    const entireScenarios: IAutoBeRealizeScenarioResult[] =
+      document.operations.map((operation) =>
+        generateRealizeScenario(ctx, operation, authorizations),
+      );
+    let bucket: IBucket = await process(entireScenarios);
+    for (let i: number = 0; i < 2; ++i) {
+      if (bucket.validate.result.type !== "failure") break;
+
+      const failedScenarios: IAutoBeRealizeScenarioResult[] = Array.from(
+        new Set(bucket.validate.result.diagnostics.map((f) => f.file)),
+      )
+        .map((location) =>
+          bucket.corrected.find((f) => f.location === location),
+        )
+        .filter((f) => f !== undefined)
+        .map((f) =>
+          entireScenarios.find(
+            (s) =>
+              s.operation.path === f.endpoint.path &&
+              s.operation.method === f.endpoint.method,
+          ),
+        )
+        .filter((o) => o !== undefined);
+      if (failedScenarios.length === 0) break;
+
+      writeProgress.total += failedScenarios.length;
+      correctProgress.total += failedScenarios.length;
+
+      const newBucket: IBucket = await process(failedScenarios);
+      const corrected: Map<string, AutoBeRealizeFunction> = new Map([
+        ...bucket.corrected.map((f) => [f.location, f] as const),
+        ...newBucket.corrected.map((f) => [f.location, f] as const),
+      ]);
+      bucket = {
+        corrected: Array.from(corrected.values()),
+        validate: newBucket.validate,
+      };
+    }
 
-    const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
         document: ctx.state().interface!.document,
-        functions: totalCorrected,
+        functions: bucket.corrected,
         authorizations,
       });
-
-    const { result } = await compileRealizeFiles(ctx, {
-      authorizations,
-      functions: totalCorrected,
-    });
-
     return ctx.dispatch({
       type: "realizeComplete",
       id: v7(),
       created_at: new Date().toISOString(),
-      functions: totalCorrected,
+      functions: bucket.corrected,
       authorizations,
       controllers,
-      compiled: result,
+      compiled: bucket.validate.result,
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });
   };
+
+interface IBucket {
+  corrected: AutoBeRealizeFunction[];
+  validate: AutoBeRealizeValidateEvent;
+}