@autobe/agent 0.20.0 → 0.21.0

package/src/context/AutoBeContext.ts

@@ -1,6 +1,7 @@
 import {
   IAgenticaVendor,
   IMicroAgenticaHistoryJson,
+  MicroAgentica,
   MicroAgenticaHistory,
 } from "@agentica/core";
 import {
@@ -49,6 +50,7 @@ export interface AutoBeContext<Model extends ILlmSchema.Model> {
   // factories
   conversate(
     props: AutoBeContext.IConversate<Model>,
+    closure?: (agent: MicroAgentica<Model>) => void,
   ): Promise<AutoBeContext.IResult<Model>>;
 }
 export namespace AutoBeContext {

package/src/factory/createAutoBeContext.ts

@@ -63,7 +63,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
     setTimeout(() => props.dispatch(message).catch(() => {}));
     return message;
   },
-  conversate: async (next) => {
+  conversate: async (next, closure) => {
     const execute = async (): Promise<AutoBeContext.IResult<Model>> => {
       const agent: MicroAgentica<Model> = new MicroAgentica<Model>({
         model: props.model,
@@ -118,6 +118,7 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
           })
           .catch(() => {});
       });
+      if (closure) closure(agent);
 
       const histories: MicroAgenticaHistory<Model>[] = await agent.conversate(
         next.message,

package/src/orchestrate/interface/histories/transformInterfaceEndpointsReviewHistories.ts

@@ -0,0 +1,39 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
+
+export const transformInterfaceEndpointsReviewHistories = (
+  state: AutoBeState,
+  endpoints: AutoBeOpenApi.IEndpoint[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => [
+  {
+    type: "systemMessage",
+    id: v4(),
+    created_at: new Date().toISOString(),
+    text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
+  },
+  ...transformInterfaceAssetHistories(state),
+  {
+    id: v4(),
+    type: "assistantMessage",
+    text: [
+      "Below are endpoints generated by your request.",
+      "```json",
+      JSON.stringify(endpoints),
+      "```",
+    ].join("\n"),
+    created_at: new Date().toISOString(),
+  },
+  {
+    id: v4(),
+    type: "systemMessage",
+    text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINTS_REVIEW,
+    created_at: new Date().toISOString(),
+  },
+];

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -14,6 +14,7 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceEndpointHistories } from "./histories/transformInterfaceEndpointHistories";
+import { orchestrateInterfaceEndpointsReview } from "./orchestrateInterfaceEndpointsReview";
 import { IAutoBeInterfaceEndpointApplication } from "./structures/IAutoBeInterfaceEndpointApplication";
 import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
 
@@ -37,11 +38,14 @@ export async function orchestrateInterfaceEndpoints<
       ),
     )
   ).flat();
-  return new HashSet(
+
+  const deduplicated: AutoBeOpenApi.IEndpoint[] = new HashSet(
     endpoints,
     OpenApiEndpointComparator.hashCode,
     OpenApiEndpointComparator.equals,
   ).toJSON();
+
+  return orchestrateInterfaceEndpointsReview(ctx, deduplicated);
 }
 
 async function process<Model extends ILlmSchema.Model>(

package/src/orchestrate/interface/orchestrateInterfaceEndpointsReview.ts

@@ -0,0 +1,95 @@
+import { IAgenticaController } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { transformInterfaceEndpointsReviewHistories } from "./histories/transformInterfaceEndpointsReviewHistories";
+import { IAutoBeInterfaceEndpointsReviewApplication } from "./structures/IAutoBeInterfaceEndpointsReviewApplication";
+
+export async function orchestrateInterfaceEndpointsReview<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  endpoints: AutoBeOpenApi.IEndpoint[],
+  message: string = `Review the generated endpoints`,
+): Promise<AutoBeOpenApi.IEndpoint[]> {
+  const pointer: IPointer<IAutoBeInterfaceEndpointsReviewApplication.IProps | null> =
+    {
+      value: null,
+    };
+
+  const { tokenUsage } = await ctx.conversate({
+    source: "interfaceEndpointsReview",
+    histories: transformInterfaceEndpointsReviewHistories(
+      ctx.state(),
+      endpoints,
+    ),
+    controller: createController({
+      model: ctx.model,
+      build: (props) => {
+        pointer.value = props;
+      },
+    }),
+    enforceFunctionCall: true,
+    message,
+  });
+
+  if (pointer.value === null) {
+    return endpoints;
+  }
+
+  const response = pointer.value?.endpoints ?? [];
+
+  ctx.dispatch({
+    id: v7(),
+    type: "interfaceEndpointsReview",
+    endpoints,
+    content: response,
+    created_at: new Date().toISOString(),
+    review: pointer.value?.review,
+    step: ctx.state().analyze?.step ?? 0,
+    tokenUsage,
+  });
+
+  return response;
+}
+
+export function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (props: IAutoBeInterfaceEndpointsReviewApplication.IProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "interface",
+    application,
+    execute: {
+      reviewEndpoints: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeInterfaceEndpointsReviewApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeInterfaceEndpointsReviewApplication,
+  "claude"
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeInterfaceEndpointsReviewApplication,
+    "chatgpt"
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};

package/src/orchestrate/interface/orchestrateInterfaceOperationsReview.ts

@@ -2,9 +2,10 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeInterfaceOperationsReviewEvent,
   AutoBeOpenApi,
+  AutoBePrisma,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
@@ -21,6 +22,7 @@ export async function orchestrateInterfaceOperationsReview<
   progress: AutoBeProgressEventBase,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   try {
+    const files: AutoBePrisma.IFile[] = ctx.state().prisma?.result.data.files!;
     const pointer: IPointer<IAutoBeInterfaceOperationsReviewApplication.IProps | null> =
       {
         value: null,
@@ -30,6 +32,7 @@ export async function orchestrateInterfaceOperationsReview<
       histories: transformInterfaceOperationsReviewHistories(ctx, operations),
       controller: createReviewController({
         model: ctx.model,
+        prismaSchemas: files,
         build: (next: IAutoBeInterfaceOperationsReviewApplication.IProps) => {
           pointer.value = next;
         },
@@ -73,11 +76,102 @@ export async function orchestrateInterfaceOperationsReview<
 
 function createReviewController<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  prismaSchemas: AutoBePrisma.IFile[];
   build: (reviews: IAutoBeInterfaceOperationsReviewApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> =
+      typia.validate<IAutoBeInterfaceOperationsReviewApplication.IProps>(next);
+    if (result.success === false) return result;
+    const errors: IValidation.IError[] = [];
+
+    const models: AutoBePrisma.IModel[] = props.prismaSchemas.flatMap(
+      (schema) => schema.models,
+    );
+
+    result.data.content.forEach((op, index) => {
+      // Check if summary or description mentions soft delete
+      const mentionsSoftDelete =
+        (op.summary && /soft[\s-]?delet/i.test(op.summary)) ||
+        (op.description && /soft[\s-]?delet/i.test(op.description));
+
+      if (op.method === "delete") {
+        const model = models.find((model) => model.name === op.model_name);
+
+        if (mentionsSoftDelete) {
+          // If soft delete is mentioned but no soft_delete_column is specified
+          if (!op.soft_delete_column) {
+            // Check if any soft-delete capable column exists in the model
+            const hasSoftDeleteCapableColumn = model?.plainFields.some(
+              (field) =>
+                /delete|deleted|deleted_at|deletedAt|is_deleted|isDeleted/i.test(
+                  field.name,
+                ),
+            );
+
+            if (hasSoftDeleteCapableColumn) {
+              errors.push({
+                expected: `Soft delete column to be specified or summary/description to not mention soft delete`,
+                value: "null",
+                description: `Mismatch: Operation mentions soft delete but soft_delete_column is not specified, while model has soft-delete capable columns`,
+                path: `$input.content[${index}].soft_delete_column`,
+              });
+            } else {
+              errors.push({
+                expected: `Summary/description to not mention soft delete when model lacks soft-delete capability`,
+                value: `${op.summary || ""} ${op.description || ""}`,
+                description: `Mismatch: Operation mentions soft delete but model '${op.model_name}' has no soft-delete capable columns`,
+                path: `$input.content[${index}].summary || $input.content[${index}].description`,
+              });
+            }
+          } else {
+            // If soft_delete_column is specified, check if it exists in the model
+            const column = model?.plainFields.find(
+              (el) => el.name === op.soft_delete_column,
+            );
+
+            if (!column) {
+              errors.push({
+                expected: `Field '${op.soft_delete_column}' to exist in model or operation to not mention soft delete`,
+                value: "undefined",
+                description: `Mismatch: Either the field '${op.soft_delete_column}' should exist in model '${op.model_name}', or the operation should not mention soft delete`,
+                path: `$input.content[${index}].soft_delete_column || $input.content[${index}].summary || $input.content[${index}].description`,
+              });
+            }
+          }
+        }
+
+        // Also check if soft_delete_column is specified without mentioning soft delete
+        if (op.soft_delete_column && !mentionsSoftDelete) {
+          errors.push({
+            expected: `Consistency between soft_delete_column and operation description`,
+            value: `soft_delete_column: ${op.soft_delete_column}`,
+            description: `Mismatch: soft_delete_column is specified but soft delete is not mentioned in summary/description`,
+            path: `$input.content[${index}]`,
+          });
+        }
+      }
+    });
+
+    // not implemented
+    if (errors.length !== 0) {
+      console.log(JSON.stringify(errors, null, 2));
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    }
+    return result;
+  };
+
   const application: ILlmApplication<Model> = collection[
     props.model === "chatgpt" ? "chatgpt" : "claude"
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -92,12 +186,26 @@ function createReviewController<Model extends ILlmSchema.Model>(props: {
 }
 
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceOperationsReviewApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeInterfaceOperationsReviewApplication,
-    "claude"
-  >(),
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeInterfaceOperationsReviewApplication,
+      "chatgpt"
+    >({
+      validate: {
+        reviewOperations: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeInterfaceOperationsReviewApplication,
+      "claude"
+    >({
+      validate: {
+        reviewOperations: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps>;

package/src/orchestrate/interface/structures/IAutoBeInterfaceEndpointsReviewApplication.ts

@@ -0,0 +1,65 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+/**
+ * Interface for reviewing and refining API endpoints through holistic analysis.
+ * 
+ * This application performs comprehensive review of all endpoints generated
+ * through divide-and-conquer strategy, ensuring consistency, eliminating
+ * redundancy, and preventing over-engineering across the entire API surface.
+ */
+export interface IAutoBeInterfaceEndpointsReviewApplication {
+  /**
+   * Reviews and refines the complete collection of API endpoints.
+   * 
+   * This method consolidates all endpoints generated independently by different
+   * groups and performs holistic review to:
+   * - Ensure naming consistency across all endpoints
+   * - Remove duplicate or overlapping endpoints
+   * - Eliminate over-engineered solutions
+   * - Standardize path structures and HTTP methods
+   * - Verify REST API design principles
+   * 
+   * The review process examines the entire API as a cohesive system rather
+   * than individual endpoints, ensuring the final API is intuitive, maintainable,
+   * and follows best practices.
+   * 
+   * @param next - The review results and refined endpoint collection
+   */
+  reviewEndpoints(
+    next: IAutoBeInterfaceEndpointsReviewApplication.IProps,
+  ): void;
+}
+
+export namespace IAutoBeInterfaceEndpointsReviewApplication {
+  export interface IProps {
+    /**
+     * Comprehensive review analysis of all collected endpoints.
+     * 
+     * Contains detailed findings from the holistic review including:
+     * - Identified inconsistencies in naming conventions
+     * - Duplicate endpoints that serve the same purpose
+     * - Over-engineered solutions that add unnecessary complexity
+     * - Violations of REST API design principles
+     * - Recommendations for improvement and standardization
+     * 
+     * The review provides actionable feedback for creating a clean,
+     * consistent, and maintainable API structure.
+     */
+    review: string;
+
+    /**
+     * Refined collection of API endpoints after review and cleanup.
+     * 
+     * The final optimized set of endpoints after:
+     * - Removing duplicates and redundant endpoints
+     * - Standardizing naming conventions across all paths
+     * - Simplifying over-engineered solutions
+     * - Ensuring consistent REST patterns
+     * - Aligning HTTP methods with their semantic meanings
+     * 
+     * This collection represents the production-ready API structure
+     * that balances functionality with simplicity and maintainability.
+     */
+    endpoints: AutoBeOpenApi.IEndpoint[];
+  }
+}

package/src/orchestrate/interface/structures/IAutoBeInterfaceOperationsReviewApplication.ts

@@ -174,5 +174,47 @@ export namespace IAutoBeInterfaceOperationsReviewApplication {
      * database structure and business logic requirements.
      */
     prisma_schemas: string;
+
+    /**
+     * Primary Prisma model name for this operation.
+     *
+     * Identifies the main database table/model that this operation targets.
+     * This must match exactly with the Prisma model name defined in the schema.
+     * When soft deletion is specified, this model name indicates which table
+     * should be soft-deleted.
+     *
+     * For example:
+     * - In a "GET /users/:id" operation, this would be "User"
+     * - In a "POST /articles" operation, this would be "Article"
+     * - In a "DELETE /comments/:id" with soft delete, this specifies the "Comment" model to soft-delete
+     *
+     * This property is essential for:
+     * - Determining the primary entity for CRUD operations
+     * - Identifying which table to apply soft deletion to
+     * - Validating operations against the correct Prisma model
+     * - Generating appropriate database queries and validations
+     */
+    model_name: string;
+
+    /**
+     * Soft delete column name for the Prisma models.
+     *
+     * Specifies the column name used for soft deletion in the database tables
+     * associated with this operation. When set to a non-null value, it indicates
+     * that the related entities support soft deletion through this column
+     * (typically a timestamp field like `deleted_at` or `deletedAt`).
+     *
+     * When null, it means the entities involved in this operation use hard
+     * deletion or don't support deletion at all. This information is crucial
+     * for generating appropriate CRUD operations and ensuring data integrity
+     * policies are correctly implemented.
+     *
+     * Common soft delete patterns:
+     * - `"deleted_at"`: Records deletion timestamp
+     * - `"deletedAt"`: Camel-cased deletion timestamp
+     * - `"is_deleted"`: Boolean flag for deletion status
+     * - `null`: No soft deletion (hard delete only)
+     */
+    soft_delete_column: string | null;
   }
 }

package/src/orchestrate/realize/orchestrateRealizeScenario.ts

@@ -1,4 +1,8 @@
-import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import {
+  AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
+  AutoBeTestFile,
+} from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -29,7 +33,7 @@ export const orchestrateRealizeScenario = <Model extends ILlmSchema.Model>(
   operation: AutoBeOpenApi.IOperation,
   authorization?: AutoBeRealizeAuthorization,
 ): IAutoBeRealizeScenarioApplication.IProps => {
-  const testScenarios =
+  const testFiles: AutoBeTestFile[] =
     ctx
       .state()
       .test?.files.filter(
@@ -47,7 +51,7 @@ export const orchestrateRealizeScenario = <Model extends ILlmSchema.Model>(
     operation: operation,
     functionName: functionName,
     location: `src/providers/${functionName}.ts`,
-    testScenarios: testScenarios.map((el) => el.scenario.draft),
+    testFiles: testFiles,
     decoratorEvent: authorization,
   };
 };

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

@@ -1,4 +1,8 @@
-import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import {
+  AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
+  AutoBeTestFile,
+} from "@autobe/interface";
 
 export namespace IAutoBeRealizeScenarioApplication {
   export interface IProps {
@@ -28,7 +32,7 @@ export namespace IAutoBeRealizeScenarioApplication {
      * certain conditions. Used as a basis for TDD-style automated test
      * generation.
      */
-    testScenarios: string[];
+    testFiles: AutoBeTestFile[];
 
     /**
      * Optional decorator event for customizing code generation behavior.

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

@@ -18,13 +18,16 @@ export namespace IAutoBeRealizeWriteApplication {
      * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION:
      *
      * DO:
+     *
      * - Examine the actual Prisma schema model definition
      * - List EVERY field that exists in the model with exact types
      * - Explicitly note fields that DO NOT exist
-     * 
+     *
      * DO NOT:
+     *
      * - Assume common fields exist without verification
-     * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active without checking
+     * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active
+     *   without checking
      *
      * 📋 STEP 2 - FIELD INVENTORY:
      *
@@ -161,7 +164,7 @@ export namespace IAutoBeRealizeWriteApplication {
      *
      * This is the initial drafting phase where you outline the basic skeleton
      * of the function.
-     * 
+     *
      * DO NOT: Use the native Date type.
      *
      * - The function signature must correctly include `user`, `parameters`, and
@@ -174,10 +177,12 @@ export namespace IAutoBeRealizeWriteApplication {
      * Import rules:
      *
      * DO NOT:
+     *
      * - Add any new import statements manually
      * - Write import statements directly (this causes compile errors)
-     * 
-     * Note: All necessary imports are provided globally or by the system automatically.
+     *
+     * Note: All necessary imports are provided globally or by the system
+     * automatically.
      *
      * ✅ Requirements:
      *

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

@@ -19,6 +19,8 @@ const singleton = new Singleton(async (compiler: IAutoBeTestCompiler) => {
     return { [location]: content };
   };
   return {
+    ...external("node_modules/@nestia/e2e/lib/ArrayUtil.d.ts"),
+    ...external("node_modules/@nestia/e2e/lib/RandomGenerator.d.ts"),
     ...external("node_modules/@nestia/e2e/lib/TestValidator.d.ts"),
     ...external("node_modules/@nestia/fetcher/lib/IConnection.d.ts"),
   } satisfies Record<string, string>;

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

@@ -1,47 +1,59 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
 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 { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
 import { transformTestWriteHistories } from "./transformTestWriteHistories";
 
-export const transformTestCorrectHistories = (
+export const transformTestCorrectHistories = async <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
   func: IAutoBeTestFunction,
   failure: IAutoBeTypeScriptCompileResult.IFailure,
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => [
-  ...transformTestWriteHistories(func.scenario, func.artifacts),
-  {
-    id: v7(),
-    created_at: new Date().toISOString(),
-    type: "assistantMessage",
-    text: StringUtil.trim`
-      ## Generated TypeScript Code
-      \`\`\`typescript
-      ${func.script}
-      \`\`\`
+): Promise<
+  Array<
+    IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+  >
+> => {
+  const previous = await transformTestWriteHistories(
+    ctx,
+    func.scenario,
+    func.artifacts,
+  );
+  return [
+    ...previous.slice(0, -1),
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.TEST_CORRECT,
+    },
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: StringUtil.trim`
+        ${previous.at(-1)!.text}
 
-      ## Compile Errors
-      Fix the compilation error in the provided code.
+        ## Generated TypeScript Code
 
-      \`\`\`json
-      ${JSON.stringify(failure.diagnostics)}
-      \`\`\`
-    `,
-  },
-  {
-    id: v7(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: AutoBeSystemPromptConstant.TEST_CORRECT.replace(
-      "{{API_DTO_SCHEMAS}}",
-      transformTestWriteHistories.structures(func.artifacts),
-    ).replace(
-      "{{API_SDK_FUNCTIONS}}",
-      transformTestWriteHistories.functional(func.artifacts),
-    ),
-  },
-];
+        \`\`\`typescript
+        ${func.script}
+        \`\`\`
+
+        ## Compile Errors
+        
+        Fix the compilation error in the provided code.
+
+        \`\`\`json
+        ${JSON.stringify(failure.diagnostics)}
+        \`\`\`
+      `,
+    },
+  ];
+};