@autobe/agent 0.25.7 → 0.27.0

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({
+      const { metric, 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,
@@ -155,13 +165,13 @@ const correct = async <Model extends ILlmSchema.Model>(
         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 
+          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 
+          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.
@@ -185,16 +195,16 @@ const correct = async <Model extends ILlmSchema.Model>(
           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 
+          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;
+      ++props.progress.completed;
 
       if (pointer.value === null)
         return { result: "exception" as const, func: func };
@@ -218,13 +228,15 @@ 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,
+        metric,
         tokenUsage,
-        completed: progress.completed,
-        total: progress.total,
+        completed: props.progress.completed,
+        total: props.progress.total,
       });
       return {
         result: "success" as const,
@@ -237,7 +249,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 +262,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
     ctx,
     {
-      authorizations,
+      authorizations: props.authorizations,
       functions: allFunctionsForValidation,
     },
   );
@@ -260,7 +272,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 +295,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 +380,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/orchestrateRealizeWrite.ts

@@ -40,7 +40,7 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   };
 
   const dto = await getRealizeWriteDto(ctx, props.scenario.operation);
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "realizeWrite",
     histories: transformRealizeWriteHistories({
       state: ctx.state(),
@@ -97,6 +97,7 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
     id: v7(),
     location: props.scenario.location,
     content: pointer.value.revise.final ?? pointer.value.draft,
+    metric,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,

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/realize/utils/replaceImportStatements.ts

@@ -4,96 +4,6 @@ import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../../context/AutoBeContext";
 import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatements";
 
-// /**
-//  * Removes all import statements that LLM might have incorrectly added. This
-//  * includes standard library imports, auto-injected imports, and any API
-//  * structure imports with wrong paths.
-//  *
-//  * @param code - The code containing imports to remove
-//  * @param typeReferences - List of type names to specifically remove
-//  * @param decoratorType - Optional decorator type to remove
-//  * @returns Code with all imports removed
-//  */
-// function removeAllImports(
-//   code: string,
-//   typeReferences: string[],
-//   decoratorType?: string,
-// ): string {
-//   // Remove standard library and auto-injected imports
-//   let cleanedCode = code
-//     // MyGlobal - often with wrong path
-//     .replace(
-//       /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
-//       "",
-//     )
-//     // typia - various import patterns
-//     .replace(
-//       /import\s+typia\s*,\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
-//       "",
-//     )
-//     .replace(/import\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm, "")
-//     .replace(
-//       /import\s*{\s*tags\s*,\s*typia\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
-//       "",
-//     )
-//     .replace(/import\s+typia\s*from\s*["']typia["']\s*;?\s*/gm, "")
-//     // Prisma client
-//     .replace(
-//       /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
-//       "",
-//     )
-//     // uuid
-//     .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
-//     // toISOStringSafe utility
-//     .replace(
-//       /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/utils\/toISOStringSafe["']\s*;?\s*/gm,
-//       "",
-//     )
-//     // JWT imports (if LLM adds them)
-//     .replace(/import\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm, "")
-//     .replace(
-//       /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
-//       "",
-//     )
-//     // NestJS HttpException
-//     .replace(
-//       /import\s*{\s*HttpException\s*}\s*from\s*["']@nestjs\/common["']\s*;?\s*/gm,
-//       "",
-//     );
-
-//   // Remove API structure imports with wrong paths
-//   // Pattern 1: ../api/structures path (LLM often uses this wrong path)
-//   cleanedCode = cleanedCode.replace(
-//     /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
-//     "",
-//   );
-//   // Pattern 2: @ORGANIZATION/PROJECT-api path (correct path but LLM shouldn't write it)
-//   cleanedCode = cleanedCode.replace(
-//     /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
-//     "",
-//   );
-
-//   // Remove specific type imports that match our typeReferences
-//   for (const ref of typeReferences) {
-//     const typeImportRegex = new RegExp(
-//       `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
-//       "gm",
-//     );
-//     cleanedCode = cleanedCode.replace(typeImportRegex, "");
-//   }
-
-//   // Remove decorator type imports if LLM mistakenly added them
-//   if (decoratorType) {
-//     const decoratorTypeRegex = new RegExp(
-//       `import\\s*(?:type\\s*)?{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
-//       "gm",
-//     );
-//     cleanedCode = cleanedCode.replace(decoratorTypeRegex, "");
-//   }
-
-//   return cleanedCode;
-// }
-
 export async function replaceImportStatements<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {

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,
+      })),
     ),
   ];
 };

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

@@ -23,17 +23,17 @@ export const transformTestCorrectInvalidRequestHistories = (
     created_at: new Date().toISOString(),
     type: "assistantMessage",
     text: StringUtil.trim`
-        ## TypeScript Code
-        
-        \`\`\`typescript
-        ${func.script}
-        \`\`\`
+      ## TypeScript Code
+      
+      \`\`\`typescript
+      ${func.script}
+      \`\`\`
 
-        ## Compile Errors
+      ## Compile Errors
 
-        \`\`\`json
-        ${JSON.stringify(diagnostics)}
-        \`\`\`
-      `,
+      \`\`\`json
+      ${JSON.stringify(diagnostics)}
+      \`\`\`
+    `,
   },
 ];