@autobe/agent 0.25.7 → 0.26.0

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -34,7 +34,7 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
-  failures: IAutoBeRealizeFunctionFailure[],
+  previousFailures: IAutoBeRealizeFunctionFailure[][],
   progress: AutoBeProgressEventBase,
   life: number = ctx.retry,
 ): Promise<AutoBeRealizeFunction[]> {
@@ -92,32 +92,26 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     diagnosticsByFile[location].diagnostics.push(diagnostic);
   });
 
-  const newFailures: IAutoBeRealizeFunctionFailure[] = [
-    ...failures,
-    ...Object.values(diagnosticsByFile),
-  ];
-
-  const corrected: AutoBeRealizeFunction[] = await correct(
-    ctx,
+  const newFailures: IAutoBeRealizeFunctionFailure[] =
+    Object.values(diagnosticsByFile);
+  const corrected: AutoBeRealizeFunction[] = await correct(ctx, {
     locations,
     scenarios,
     authorizations,
     functions,
-    filterDiagnostics(
+    previousFailures,
+    failures: filterDiagnostics(
       newFailures,
       functions.map((fn) => fn.location),
     ),
     progress,
-  );
+  });
   return orchestrateRealizeCorrect(
     ctx,
     scenarios,
     authorizations,
     corrected,
-    filterDiagnostics(
-      newFailures,
-      corrected.map((c) => c.location),
-    ),
+    [...previousFailures, newFailures],
     progress,
     life - 1,
   );
@@ -125,61 +119,82 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
 
 async function correct<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  locations: string[],
-  scenarios: IAutoBeRealizeScenarioResult[],
-  authorizations: AutoBeRealizeAuthorization[],
-  functions: AutoBeRealizeFunction[],
-  failures: IAutoBeRealizeFunctionFailure[],
-  progress: AutoBeProgressEventBase,
+  props: {
+    locations: string[];
+    scenarios: IAutoBeRealizeScenarioResult[];
+    authorizations: AutoBeRealizeAuthorization[];
+    functions: AutoBeRealizeFunction[];
+    previousFailures: IAutoBeRealizeFunctionFailure[][];
+    failures: IAutoBeRealizeFunctionFailure[];
+    progress: AutoBeProgressEventBase;
+  },
 ): Promise<AutoBeRealizeFunction[]> {
-  if (locations.length === 0) {
-    return functions;
+  if (props.locations.length === 0) {
+    return props.functions;
   }
 
   const corrected: AutoBeRealizeFunction[] = await executeCachedBatch(
-    locations.map((location) => async (): Promise<AutoBeRealizeFunction> => {
-      const scenario = scenarios.find((el) => el.location === location);
-      const func = functions.find((el) => el.location === location);
-
-      if (!func) {
-        throw new Error("No function found for location: " + location);
-      }
-
-      const RealizeFunctionFailures: IAutoBeRealizeFunctionFailure[] =
-        failures.filter((f) => f.function?.location === location);
+    props.locations.map(
+      (location) => async (): Promise<AutoBeRealizeFunction> => {
+        const scenario = props.scenarios.find((el) => el.location === location);
+        const func = props.functions.find((el) => el.location === location);
 
-      if (RealizeFunctionFailures.length && scenario) {
-        try {
-          const correctEvent: AutoBeRealizeCorrectEvent | null = await step(
-            ctx,
-            {
-              totalAuthorizations: authorizations,
-              authorization: scenario.decoratorEvent ?? null,
-              scenario,
-              function: func,
-              failures: RealizeFunctionFailures,
-              progress: progress,
-            },
-          );
+        if (!func) {
+          throw new Error("No function found for location: " + location);
+        }
 
-          return {
-            ...func,
-            content: correctEvent === null ? "" : correctEvent.content,
-          };
-        } catch (err) {
-          return func;
+        const failures: IAutoBeRealizeFunctionFailure[] = props.failures.filter(
+          (f) => f.function?.location === location,
+        );
+        if (failures.length && scenario) {
+          try {
+            const correctEvent: AutoBeRealizeCorrectEvent | null = await step(
+              ctx,
+              {
+                totalAuthorizations: props.authorizations,
+                authorization: scenario.decoratorEvent ?? null,
+                scenario,
+                function: func,
+                previousFailures: props.previousFailures
+                  .map((pf) => {
+                    const previousFailures: IAutoBeRealizeFunctionFailure[] =
+                      pf.filter((f) => f.function.location === location);
+                    if (previousFailures.length === 0) return null;
+                    return {
+                      function: previousFailures[0].function,
+                      diagnostics: previousFailures
+                        .map((f) => f.diagnostics)
+                        .flat(),
+                    };
+                  })
+                  .filter((f) => f !== null),
+                failure: {
+                  function: failures[0].function,
+                  diagnostics: failures.map((f) => f.diagnostics).flat(),
+                },
+                progress: props.progress,
+              },
+            );
+
+            return {
+              ...func,
+              content: correctEvent === null ? "" : correctEvent.content,
+            };
+          } catch (err) {
+            return func;
+          }
         }
-      }
 
-      return func;
-    }),
+        return func;
+      },
+    ),
   );
 
   // Create a map of corrected functions for efficient lookup
   const correctedMap = new Map(corrected.map((f) => [f.location, f]));
 
   // Return all functions, with corrected ones replaced
-  return functions.map((func) => correctedMap.get(func.location) || func);
+  return props.functions.map((func) => correctedMap.get(func.location) || func);
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -189,7 +204,8 @@ async function step<Model extends ILlmSchema.Model>(
     totalAuthorizations: AutoBeRealizeAuthorization[];
     scenario: IAutoBeRealizeScenarioResult;
     function: AutoBeRealizeFunction;
-    failures: IAutoBeRealizeFunctionFailure[];
+    previousFailures: IAutoBeRealizeFunctionFailure[];
+    failure: IAutoBeRealizeFunctionFailure;
     progress: AutoBeProgressEventBase;
   },
 ): Promise<AutoBeRealizeCorrectEvent | null> {
@@ -211,11 +227,8 @@ async function step<Model extends ILlmSchema.Model>(
       state: ctx.state(),
       scenario: props.scenario,
       authorization: props.authorization,
-      code: props.function.content,
       dto,
-      failures: props.failures.filter(
-        (f) => f.function.location === props.function.location,
-      ),
+      failures: [...props.previousFailures, props.failure],
       totalAuthorizations: props.totalAuthorizations,
     }),
     enforceFunctionCall: true,
@@ -261,6 +274,7 @@ async function step<Model extends ILlmSchema.Model>(
 
   const event: AutoBeRealizeCorrectEvent = {
     type: "realizeCorrect",
+    kind: "overall",
     id: v7(),
     location: props.scenario.location,
     content: pointer.value.revise.final ?? pointer.value.draft,

package/src/orchestrate/realize/{orchestRateRealizeCorrectCasting.ts → orchestrateRealizeCorrectCasting.ts}

@@ -24,6 +24,7 @@ import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
 import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
 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";
@@ -53,94 +54,103 @@ export const orchestrateRealizeCorrectCasting = async <
   );
   return predicate(
     ctx,
-    scenarios,
-    authorizations,
-    functions,
-    [],
-    progress,
-    validateEvent,
+    {
+      scenarios,
+      authorizations,
+      functions,
+      previousFailures: [],
+      progress,
+      event: validateEvent,
+    },
     life,
   );
 };
 
 const predicate = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenarios: IAutoBeRealizeScenarioResult[],
-  authorizations: AutoBeRealizeAuthorization[],
-  functions: AutoBeRealizeFunction[],
-  failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  progress: AutoBeProgressEventBase,
-  event: AutoBeRealizeValidateEvent,
+  props: {
+    scenarios: IAutoBeRealizeScenarioResult[];
+    authorizations: AutoBeRealizeAuthorization[];
+    functions: AutoBeRealizeFunction[];
+    previousFailures: IAutoBeRealizeFunctionFailure[][];
+    progress: AutoBeProgressEventBase;
+    event: AutoBeRealizeValidateEvent;
+  },
   life: number,
 ): Promise<AutoBeRealizeFunction[]> => {
-  if (event.result.type === "failure") {
-    ctx.dispatch(event);
-    return await correct(
-      ctx,
-      scenarios,
-      authorizations,
-      functions,
-      [...failures, ...event.result.diagnostics],
-      progress,
-      event,
-      life,
-    );
+  if (props.event.result.type === "failure") {
+    ctx.dispatch(props.event);
+    return await correct(ctx, props, life);
   }
-  return functions;
+  return props.functions;
 };
 
 const correct = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenarios: IAutoBeRealizeScenarioResult[],
-  authorizations: AutoBeRealizeAuthorization[],
-  functions: AutoBeRealizeFunction[],
-  failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  progress: AutoBeProgressEventBase,
-  event: AutoBeRealizeValidateEvent,
+  props: {
+    scenarios: IAutoBeRealizeScenarioResult[];
+    authorizations: AutoBeRealizeAuthorization[];
+    functions: AutoBeRealizeFunction[];
+    previousFailures: IAutoBeRealizeFunctionFailure[][];
+    progress: AutoBeProgressEventBase;
+    event: AutoBeRealizeValidateEvent;
+  },
   life: number,
 ): Promise<AutoBeRealizeFunction[]> => {
   // Early returns for non-correctable cases
-  if (event.result.type !== "failure" || life < 0) {
-    return functions;
+  if (props.event.result.type !== "failure" || life < 0) {
+    return props.functions;
   }
 
-  const locations: string[] = diagnose(event).filter((l) =>
-    functions.map((f) => f.location).includes(l),
+  const failure = props.event.result;
+  const locations: string[] = diagnose(props.event).filter((l) =>
+    props.functions.map((f) => f.location).includes(l),
   );
 
   // If no locations to correct, return original functions
   if (locations.length === 0) {
-    return functions;
+    return props.functions;
   }
 
-  progress.total += locations.length;
+  props.progress.total += locations.length;
 
   const converted: CorrectionResult[] = await executeCachedBatch(
     locations.map((location) => async (): Promise<CorrectionResult> => {
-      const func: AutoBeRealizeFunction = functions.find(
+      const func: AutoBeRealizeFunction = props.functions.find(
         (f) => f.location === location,
       )!;
-      const scenario: IAutoBeRealizeScenarioResult = scenarios.find(
+      const scenario: IAutoBeRealizeScenarioResult = props.scenarios.find(
         (s) => s.location === func.location,
       )!;
       const operation: AutoBeOpenApi.IOperation = scenario.operation;
       const authorization: AutoBeRealizeAuthorization | undefined =
-        authorizations.find((a) => a.role.name === operation.authorizationRole);
+        props.authorizations.find(
+          (a) => a.actor.name === operation.authorizationActor,
+        );
 
       const pointer: IPointer<
         IAutoBeCommonCorrectCastingApplication.IProps | false | null
       > = {
         value: null,
       };
-
       const { tokenUsage } = await ctx.conversate({
         source: "realizeCorrect",
-        histories: transformRealizeCorrectCastingHistories([
-          {
-            script: func.content,
-            diagnostics: failures.filter((d) => d.file === location),
-          },
-        ]),
+        histories: transformRealizeCorrectCastingHistories({
+          failures: [
+            ...props.previousFailures
+              .map(
+                (pf) =>
+                  pf.find((f) => f.function.location === func.location) ?? null,
+              )
+              .filter((x) => x !== null),
+            {
+              function: func,
+              diagnostics: failure.diagnostics.filter(
+                (d) => d.file === func.location,
+              ),
+            },
+          ],
+        }),
         controller: createController({
           model: ctx.model,
           functionName: scenario.functionName,
@@ -194,7 +204,7 @@ const correct = async <Model extends ILlmSchema.Model>(
           I repeat that, never assert the Prisma type. It's not your mission.
         `,
       });
-      ++progress.completed;
+      ++props.progress.completed;
 
       if (pointer.value === null)
         return { result: "exception" as const, func: func };
@@ -218,13 +228,14 @@ const correct = async <Model extends ILlmSchema.Model>(
       ctx.dispatch({
         id: v7(),
         type: "realizeCorrect",
+        kind: "casting",
         content: pointer.value.revise.final ?? pointer.value.draft,
         created_at: new Date().toISOString(),
         location: func.location,
         step: ctx.state().analyze?.step ?? 0,
         tokenUsage,
-        completed: progress.completed,
-        total: progress.total,
+        completed: props.progress.completed,
+        total: props.progress.total,
       });
       return {
         result: "success" as const,
@@ -237,7 +248,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   );
 
   // Get functions that were not modified (not in locations array)
-  const unchangedFunctions: AutoBeRealizeFunction[] = functions.filter(
+  const unchangedFunctions: AutoBeRealizeFunction[] = props.functions.filter(
     (f) => !locations.includes(f.location),
   );
 
@@ -250,7 +261,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
     ctx,
     {
-      authorizations,
+      authorizations: props.authorizations,
       functions: allFunctionsForValidation,
     },
   );
@@ -260,7 +271,7 @@ const correct = async <Model extends ILlmSchema.Model>(
     return allFunctionsForValidation;
   } else if (newResult.type === "exception") {
     // Compilation exception, return current functions. because retrying won't help.
-    return functions;
+    return props.functions;
   }
 
   if (
@@ -283,27 +294,33 @@ const correct = async <Model extends ILlmSchema.Model>(
     return [...success, ...ignored, ...unchangedFunctions];
   }
 
-  // Collect diagnostics relevant to failed functions
-  const failedLocations: string[] = failed.map((f) => f.location);
-  const allDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] = [
-    ...failures,
-    ...(newResult.type === "failure" ? newResult.diagnostics : []),
-  ];
-  const relevantDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] =
-    filterRelevantDiagnostics(allDiagnostics, failedLocations);
-
   // Recursively retry failed functions
   const retriedFunctions: AutoBeRealizeFunction[] = await predicate(
     ctx,
-    scenarios,
-    authorizations,
-    failed,
-    relevantDiagnostics,
-    progress,
-    newValidate,
+    {
+      scenarios: props.scenarios,
+      authorizations: props.authorizations,
+      functions: failed,
+      previousFailures: [
+        ...props.previousFailures,
+        failed.map(
+          (f) =>
+            ({
+              function: f,
+              diagnostics:
+                newValidate.result.type === "failure"
+                  ? newValidate.result.diagnostics.filter(
+                      (d) => d.file === f.location,
+                    )
+                  : [],
+            }) satisfies IAutoBeRealizeFunctionFailure,
+        ),
+      ],
+      progress: props.progress,
+      event: newValidate,
+    },
     life - 1,
   );
-
   return [...success, ...ignored, ...retriedFunctions, ...unchangedFunctions];
 };
 
@@ -362,22 +379,6 @@ const separateCorrectionResults = (
   return { success, failed, ignored };
 };
 
-/**
- * Filter diagnostics to only include those relevant to specific functions
- *
- * @param diagnostics - All diagnostics
- * @param functionLocations - Locations of functions to filter for
- * @returns Filtered diagnostics
- */
-const filterRelevantDiagnostics = (
-  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  functionLocations: string[],
-): IAutoBeTypeScriptCompileResult.IDiagnostic[] => {
-  return diagnostics.filter(
-    (d) => d.file && functionLocations.includes(d.file),
-  );
-};
-
 const createController = <Model extends ILlmSchema.Model>(props: {
   model: Model;
   functionName: string;

package/src/orchestrate/realize/structures/IAutoBeRealizeAuthorizationApplication.ts

@@ -83,7 +83,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
 
   export interface IDecorator {
     /**
-     * The name of the Decorator to be generated in {Role}Auth format (e.g.,
+     * The name of the Decorator to be generated in {Actor}Auth format (e.g.,
      * AdminAuth, UserAuth). This decorator will be used as a parameter
      * decorator in Controller methods to automatically authenticate and
      * authorize users for the specific role, injecting the authenticated user
@@ -106,7 +106,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
 
   export interface IPayloadType {
     /**
-     * The name of the Payload type to be generated in {Role}Payload format
+     * The name of the Payload type to be generated in {Actor}Payload format
      * (e.g., AdminPayload, UserPayload). This type defines the structure of the
      * authenticated user data that will be injected into Controller methods
      * when using the decorator.
@@ -116,7 +116,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
     name: string & PascalCasePattern;
 
     /**
-     * Complete TypeScript code for the Payload type interface in {Role}Payload
+     * Complete TypeScript code for the Payload type interface in {Actor}Payload
      * format (e.g., AdminPayload, UserPayload). Must include: id field with
      * UUID format validation, type field as role discriminator, and proper
      * typia tags for validation. This interface defines the structure of the

package/src/orchestrate/realize/utils/AutoBeRealizeAuthorizationReplaceImport.ts

@@ -1,9 +1,12 @@
 export namespace AutoBeRealizeAuthorizationReplaceImport {
-  export function replaceProviderImport(role: string, content: string): string {
+  export function replaceProviderImport(
+    actor: string,
+    content: string,
+  ): string {
     let updatedContent = content;
 
-    const roleCapitalized =
-      role.charAt(0).toUpperCase() + role.slice(1).toLowerCase();
+    const actorCapitalized =
+      actor.charAt(0).toUpperCase() + actor.slice(1).toLowerCase();
 
     const nestjsCommonPattern =
       /import\s+{\s*[^}]*\s*}\s+from\s+"@nestjs\/common";/g;
@@ -19,7 +22,7 @@ export namespace AutoBeRealizeAuthorizationReplaceImport {
       'import { jwtAuthorize } from "./jwtAuthorize";';
 
     const payloadPattern = /import\s+{\s*\w*Payload\s*}\s+from\s+[^;]+;/g;
-    const payloadReplacement = `import { ${roleCapitalized}Payload } from "../../decorators/payload/${roleCapitalized}Payload";`;
+    const payloadReplacement = `import { ${actorCapitalized}Payload } from "../../decorators/payload/${actorCapitalized}Payload";`;
 
     // 각 패턴을 순차적으로 적용
     updatedContent = updatedContent.replace(
@@ -40,18 +43,18 @@ export namespace AutoBeRealizeAuthorizationReplaceImport {
   }
 
   export function replaceDecoratorImport(
-    role: string,
+    actor: string,
     content: string,
   ): string {
     let updatedContent = content;
 
-    const roleLowercase = role.toLowerCase();
+    const actorLowercase = actor.toLowerCase();
 
     // ~Authorize로 끝나는 import 구문을 특정 경로로 변경하는 정규표현식
     const authorizePattern = /import\s+{\s*\w*Authorize\s*}\s+from\s+[^;]+;/g;
 
     // role을 기반으로 동적으로 replacement 생성
-    const authorizeReplacement = `import { ${roleLowercase}Authorize } from "../providers/authorize/${roleLowercase}Authorize";`;
+    const authorizeReplacement = `import { ${actorLowercase}Authorize } from "../providers/authorize/${actorLowercase}Authorize";`;
 
     // 패턴 적용
     updatedContent = updatedContent.replace(

package/src/orchestrate/realize/utils/generateRealizeScenario.ts

@@ -34,7 +34,7 @@ export function generateRealizeScenario<Model extends ILlmSchema.Model>(
   authorizations: AutoBeRealizeAuthorization[],
 ): IAutoBeRealizeScenarioResult {
   const authorization = authorizations.find(
-    (el) => el.role.name === operation.authorizationRole,
+    (el) => el.actor.name === operation.authorizationActor,
   );
 
   const testFiles: AutoBeTestFile[] =

package/src/orchestrate/realize/utils/getRealizeWriteCodeTemplate.ts

@@ -42,9 +42,9 @@ export function getRealizeWriteCodeTemplate(props: {
   const functionParameters: string[] = [];
 
   // Add authentication parameter if needed (e.g., user: IUser, admin: IAdmin)
-  if (props.authorization && props.authorization.role.name) {
+  if (props.authorization && props.authorization.actor.name) {
     // Debug: Log the values to check what's being used
-    const authParameter = `${props.authorization.role.name}: ${props.authorization.payload.name}`;
+    const authParameter = `${props.authorization.actor.name}: ${props.authorization.payload.name}`;
     functionParameters.push(authParameter);
   }
 

package/src/orchestrate/realize/utils/getRealizeWriteDto.ts

@@ -37,7 +37,7 @@ function filterDocument(
   document: AutoBeOpenApi.IDocument,
 ): AutoBeOpenApi.IDocument {
   const components: AutoBeOpenApi.IComponents = {
-    authorization: document.components.authorization,
+    authorizations: document.components.authorizations,
     schemas: {},
   };
 

package/src/orchestrate/realize/utils/getRealizeWriteInputType.ts

@@ -36,9 +36,9 @@ export function getRealizeWriteInputType(
   const functionParameterFields: string[] = [];
 
   // Add authentication field (user/admin/member) if endpoint requires auth
-  const hasAuthentication = authorization && operation.authorizationRole;
+  const hasAuthentication = authorization && operation.authorizationActor;
   if (hasAuthentication) {
-    const authFieldName = operation.authorizationRole;
+    const authFieldName = operation.authorizationActor;
     const authFieldType = authorization.payload.name;
     functionParameterFields.push(`${authFieldName}: ${authFieldType};`);
   }

package/src/orchestrate/realize/utils/printErrorHints.ts

@@ -51,5 +51,5 @@ export function printErrorHints(
         \`\`\`
       `;
     })
-    .join("\n");
+    .join("\n\n");
 }

package/src/orchestrate/test/compile/getTestScenarioArtifacts.ts

@@ -57,7 +57,7 @@ function filterDocument(
       ),
   );
   const components: AutoBeOpenApi.IComponents = {
-    authorization: document.components.authorization,
+    authorizations: document.components.authorizations,
     schemas: {},
   };
   const visit = (typeName: string) => {

package/src/orchestrate/test/histories/transformTestCorrectHistories.ts

@@ -1,10 +1,10 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { StringUtil } from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../../context/AutoBeContext";
+import { transformPreviousAndLatestCorrectHistories } from "../../common/histories/transformPreviousAndLatestCorrectHistories";
 import { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
 import { IAutoBeTestFunctionFailure } from "../structures/IAutoBeTestFunctionFailure";
 import { transformTestWriteHistories } from "./transformTestWriteHistories";
@@ -39,29 +39,11 @@ export const transformTestCorrectHistories = async <
       text: AutoBeSystemPromptConstant.TEST_CORRECT,
     },
     previous.at(-1)!,
-    ...props.failures.map(
-      (f, i, array) =>
-        ({
-          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.function.script}
-            \`\`\`
-
-            ### Compile Errors
-
-            Fix the compilation error in the provided code.
-
-            \`\`\`json
-            ${JSON.stringify(f.failure.diagnostics)}
-            \`\`\`
-          `,
-        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ...transformPreviousAndLatestCorrectHistories(
+      props.failures.map((f) => ({
+        script: f.function.script,
+        diagnostics: f.failure.diagnostics,
+      })),
     ),
   ];
 };