@autobe/agent 0.21.0 → 0.22.1

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

@@ -0,0 +1,82 @@
+import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+
+/**
+ * Generate TypeScript type definition string for provider function props
+ *
+ * This utility creates the exact props interface that the Realize Agent's
+ * generated provider functions must accept. It combines:
+ *
+ * - Authentication context (user/admin/member from authorization)
+ * - URL path parameters (e.g., id, boardId, postId)
+ * - Request body type (if applicable)
+ *
+ * The output is injected into REALIZE_WRITE_ARTIFACT.md template to tell the AI
+ * exactly what parameter type the function should accept.
+ *
+ * @example
+ *   // For DELETE /posts/:id (authenticated)
+ *   // Returns: "props: { user: IUser; id: string & tags.Format<'uuid'>; }"
+ *
+ * @example
+ *   // For GET /public/info (no auth, no params)
+ *   // Returns: "// No props parameter needed - function should have no parameters"
+ *
+ * @param operation - OpenAPI operation definition containing parameters and
+ *   auth requirements
+ * @param authorization - Authorization context with user/role information (if
+ *   authenticated endpoint)
+ * @returns TypeScript interface string like "props: { user: IUser; id: string;
+ *   body: IRequest; }"
+ */
+export function getRealizeWriteInputType(
+  operation: AutoBeOpenApi.IOperation,
+  authorization: AutoBeRealizeAuthorization | null,
+): string {
+  const functionParameterFields: string[] = [];
+
+  // Add authentication field (user/admin/member) if endpoint requires auth
+  const hasAuthentication = authorization && operation.authorizationRole;
+  if (hasAuthentication) {
+    const authFieldName = operation.authorizationRole;
+    const authFieldType = authorization.payload.name;
+    functionParameterFields.push(`${authFieldName}: ${authFieldType};`);
+  }
+
+  // Add URL path parameters (e.g., /posts/:id → id parameter)
+  const pathParameters = operation.parameters;
+  pathParameters.forEach((pathParam) => {
+    const paramName = pathParam.name;
+    const paramType = pathParam.schema.type;
+    const paramFormat =
+      "format" in pathParam.schema
+        ? ` & tags.Format<'${pathParam.schema.format}'>`
+        : "";
+
+    const parameterField = `${paramName}: ${paramType}${paramFormat};`;
+    functionParameterFields.push(parameterField);
+  });
+
+  // Add request body if present (POST/PUT/PATCH operations)
+  const hasRequestBody = operation.requestBody?.typeName;
+  if (hasRequestBody) {
+    const bodyTypeName = operation.requestBody?.typeName;
+    functionParameterFields.push(`body: ${bodyTypeName};`);
+  }
+
+  // Format as TypeScript props interface or indicate no parameters needed
+  const hasParameters = functionParameterFields.length > 0;
+
+  if (!hasParameters) {
+    return `// No props parameter needed - function should have no parameters`;
+  }
+
+  const formattedFields = functionParameterFields
+    .map((field) => `  ${field}`)
+    .join("\n");
+
+  return StringUtil.trim`
+    props: {
+    ${formattedFields}
+    }`;
+}

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

@@ -1,133 +1,123 @@
-import { IAutoBeCompiler } from "@autobe/interface";
+import { AutoBeOpenApi, IAutoBeCompiler } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../../context/AutoBeContext";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatements";
 
-export function replaceImportStatements<Model extends ILlmSchema.Model>(
+export async function replaceImportStatements<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  props: {
+    operation: AutoBeOpenApi.IOperation;
+    code: string;
+    decoratorType?: string;
+  },
 ) {
-  return async function (
-    artifacts: IAutoBeTestScenarioArtifacts,
-    code: string,
-    decoratorType?: string,
-  ) {
-    const typeReferences: string[] = Array.from(
-      new Set(
-        Object.keys(artifacts.document.components.schemas).map(
-          (key) => key.split(".")[0]!,
-        ),
-      ),
-    );
+  let { operation, code, decoratorType } = props;
 
-    const compiler: IAutoBeCompiler = await ctx.compiler();
-    code = await compiler.typescript.beautify(code);
-    // Remove existing import statements using flexible regex patterns
-    code = code
-      .replace(
-        /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
-        "",
-      )
-      .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, "")
-      .replace(
-        /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
-        "",
-      )
-      .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
-      .replace(
-        /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/util\/toISOStringSafe["']\s*;?\s*/gm,
-        "",
-      )
-      // Remove JWT import if it exists (to prevent duplication)
-      .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,
-        "",
-      );
+  const typeReferences: string[] = Array.from(
+    new Set(
+      [operation.requestBody, operation.responseBody]
+        .filter((el) => el !== null)
+        .map((el) => el.typeName.split(".")[0]!),
+    ),
+  );
 
-    // Remove any existing API structure imports
-    // Pattern 1: ../api/structures path
-    code = code.replace(
-      /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  code = await compiler.typescript.beautify(code);
+  // Remove existing import statements using flexible regex patterns
+  code = code
+    .replace(
+      /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
       "",
-    );
-    // Pattern 2: @ORGANIZATION/PROJECT-api/lib/structures path
-    code = code.replace(
-      /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
+    )
+    .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, "")
+    .replace(
+      /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
+      "",
+    )
+    .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
+    .replace(
+      /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/util\/toISOStringSafe["']\s*;?\s*/gm,
+      "",
+    )
+    // Remove JWT import if it exists (to prevent duplication)
+    .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,
       "",
     );
 
-    // Remove specific type imports that match our typeReferences
-    for (const ref of typeReferences) {
-      // Remove any import of this specific type from any path
-      const typeImportRegex = new RegExp(
-        `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
-        "gm",
-      );
-      code = code.replace(typeImportRegex, "");
-    }
+  // Remove any existing API structure imports
+  // Pattern 1: ../api/structures path
+  code = code.replace(
+    /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
+    "",
+  );
+  // Pattern 2: @ORGANIZATION/PROJECT-api/lib/structures path
+  code = code.replace(
+    /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
+    "",
+  );
 
-    // Remove any existing decoratorType 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",
-      );
-      code = code.replace(decoratorTypeRegex, "");
-    }
+  // Remove specific type imports that match our typeReferences
+  for (const ref of typeReferences) {
+    // Remove any import of this specific type from any path
+    const typeImportRegex = new RegExp(
+      `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
+      "gm",
+    );
+    code = code.replace(typeImportRegex, "");
+  }
 
-    // Build the standard imports
-    const imports = [
-      'import jwt from "jsonwebtoken";',
-      'import { MyGlobal } from "../MyGlobal";',
-      'import typia, { tags } from "typia";',
-      'import { Prisma } from "@prisma/client";',
-      'import { v4 } from "uuid";',
-      'import { toISOStringSafe } from "../util/toISOStringSafe"',
-      ...typeReferences.map(
-        (ref) =>
-          `import { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
-      ),
-    ];
+  // Remove any existing decoratorType 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",
+    );
+    code = code.replace(decoratorTypeRegex, "");
+  }
 
-    // Only add decoratorType import if it exists
-    if (decoratorType) {
-      imports.push(
-        `import { ${decoratorType} } from "../decorators/payload/${decoratorType}"`,
-      );
-    }
+  // Build the standard imports
+  const imports = getRealizeWriteImportStatements(operation);
+
+  // Only add decoratorType import if it exists
+  if (decoratorType) {
+    imports.push(
+      `import { ${decoratorType} } from "../decorators/payload/${decoratorType}"`,
+    );
+  }
 
-    code = [...imports, "", code].join("\n");
+  code = [...imports, "", code].join("\n");
 
-    // Clean up formatting issues
-    code =
-      code
-        // Remove lines with only whitespace
-        .replace(/^\s+$/gm, "")
-        // Replace 3+ consecutive newlines with exactly 2 newlines
-        .replace(/\n{3,}/g, "\n\n")
-        // Ensure proper spacing after import section
-        .replace(/(import.*?;)(\s*)(\n(?!import|\s*$))/g, "$1\n\n$3")
-        // Trim and ensure single trailing newline
-        .trim() + "\n";
+  // Clean up formatting issues
+  code =
+    code
+      // Remove lines with only whitespace
+      .replace(/^\s+$/gm, "")
+      // Replace 3+ consecutive newlines with exactly 2 newlines
+      .replace(/\n{3,}/g, "\n\n")
+      // Ensure proper spacing after import section
+      .replace(/(import.*?;)(\s*)(\n(?!import|\s*$))/g, "$1\n\n$3")
+      // Trim and ensure single trailing newline
+      .trim() + "\n";
 
-    // fix escaped codes
-    code = code.replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\'/g, "'");
+  // fix escaped codes
+  code = code.replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\'/g, "'");
 
-    // Apply final beautification
-    code = await compiler.typescript.beautify(code);
+  // Apply final beautification
+  code = await compiler.typescript.beautify(code);
 
-    code = code.replaceAll("typia.tags.assert", "typia.assert");
+  code = code.replaceAll("typia.tags.assert", "typia.assert");
 
-    return code;
-  };
+  return code;
 }

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

@@ -1,39 +1,26 @@
 import { StringUtil } from "@autobe/utils";
+import { ILlmSchema } from "@samchon/openapi";
 
+import { AutoBeContext } from "../../../context/AutoBeContext";
 import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
+import { getTestImportStatements } from "./getTestImportStatements";
 
-export function completeTestCode(
+export const completeTestCode = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
   artifacts: IAutoBeTestScenarioArtifacts,
   code: string,
-): string {
-  const typeReferences: string[] = Array.from(
-    new Set(
-      Object.keys(artifacts.document.components.schemas).map(
-        (key) => key.split(".")[0]!,
-      ),
-    ),
-  );
-
-  code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
-  code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
-  code = code.replaceAll(
-    'string & Format<"uuid">',
-    'string & tags.Format<"uuid">',
-  );
-  code = StringUtil.trim`
-    import { ArrayUtil, RandomGenerator, TestValidator } from "@nestia/e2e";
-    import { IConnection } from "@nestia/fetcher";
-    import typia, { tags } from "typia";
-    
-    import api from "@ORGANIZATION/PROJECT-api";
-    ${typeReferences
-      .map(
-        (ref) =>
-          `import type { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
-      )
-      .join("\n")}
+): Promise<string> => {
+  const compiler = await ctx.compiler();
+  code = await compiler.typescript.beautify(code);
+  code = code
+    .split("\r\n")
+    .join("\n")
+    .split("\n")
+    .filter((str) => str.trim().startsWith("import") === false)
+    .join("\n");
+  return await compiler.typescript.beautify(StringUtil.trim`
+    ${getTestImportStatements(artifacts.document)}
     
     ${code}
-  `;
-  return code;
-}
+  `);
+};

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

@@ -18,10 +18,22 @@ const singleton = new Singleton(async (compiler: IAutoBeTestCompiler) => {
     if (content === undefined) throw new Error(`File not found: ${location}`);
     return { [location]: content };
   };
+  const filter = (
+    closure: (key: string) => boolean,
+  ): Record<string, string> => {
+    const entries = Object.entries(records).filter(([key]) => closure(key));
+    return Object.fromEntries(entries);
+  };
   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"),
+    ...external("node_modules/@samchon/openapi/lib/http/HttpError.d.ts"),
+    ...external("node_modules/typia/lib/module.d.ts"),
+    ...filter(
+      (key) =>
+        key.startsWith("node_modules/typia/lib/tags") && key.endsWith(".d.ts"),
+    ),
   } satisfies Record<string, string>;
 });

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

@@ -0,0 +1,25 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+
+export const getTestImportStatements = (
+  document: AutoBeOpenApi.IDocument,
+): string => {
+  const typeReferences: string[] = Array.from(
+    new Set(
+      Object.keys(document.components.schemas).map((key) => key.split(".")[0]!),
+    ),
+  ).sort();
+  return StringUtil.trim`
+    import { ArrayUtil, RandomGenerator, TestValidator } from "@nestia/e2e";
+    import { IConnection } from "@nestia/fetcher";
+    import typia, { tags } from "typia";
+    
+    import api from "@ORGANIZATION/PROJECT-api";
+    ${typeReferences
+      .map(
+        (ref) =>
+          `import type { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
+      )
+      .join("\n")}
+  `;
+};

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

@@ -7,10 +7,14 @@ import { ILlmSchema, OpenApiTypeChecker } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../../context/AutoBeContext";
 import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
+import { getTestTemplateCode } from "./getTestTemplateCode";
 
 export async function getTestScenarioArtifacts<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenario: Pick<AutoBeTestScenario, "endpoint" | "dependencies">,
+  scenario: Pick<
+    AutoBeTestScenario,
+    "endpoint" | "dependencies" | "functionName"
+  >,
 ): Promise<IAutoBeTestScenarioArtifacts> {
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const document: AutoBeOpenApi.IDocument = filterDocument(
@@ -35,6 +39,7 @@ export async function getTestScenarioArtifacts<Model extends ILlmSchema.Model>(
     sdk: filter("src/api", "src/api/structures"),
     dto: filter("src/api/structures"),
     e2e: filter("test/features"),
+    template: getTestTemplateCode(scenario, document),
   };
 }
 

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

@@ -0,0 +1,25 @@
+import { AutoBeOpenApi, AutoBeTestScenario } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+
+import { getTestImportStatements } from "./getTestImportStatements";
+
+export const getTestTemplateCode = (
+  scenario: Pick<
+    AutoBeTestScenario,
+    "endpoint" | "dependencies" | "functionName"
+  >,
+  document: AutoBeOpenApi.IDocument,
+): string => {
+  return StringUtil.trim`
+    ${getTestImportStatements(document)}
+
+    /**
+     * <SCENARIO DESCRIPTION HERE>
+     */
+    export async function ${scenario.functionName}(
+      connection: api.IConnection,
+    ) {
+      // <E2E TEST CODE HERE>
+    }
+  `;
+};

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

@@ -1,12 +1,12 @@
 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 { v4, v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../../context/AutoBeContext";
 import { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
+import { IAutoBeTestFunctionFailure } from "../structures/IAutoBeTestFunctionFailure";
 import { transformTestWriteHistories } from "./transformTestWriteHistories";
 
 export const transformTestCorrectHistories = async <
@@ -14,17 +14,15 @@ export const transformTestCorrectHistories = async <
 >(
   ctx: AutoBeContext<Model>,
   func: IAutoBeTestFunction,
-  failure: IAutoBeTypeScriptCompileResult.IFailure,
+  failures: IAutoBeTestFunctionFailure[],
 ): Promise<
   Array<
     IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
   >
 > => {
-  const previous = await transformTestWriteHistories(
-    ctx,
-    func.scenario,
-    func.artifacts,
-  );
+  const previous: Array<
+    IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+  > = await transformTestWriteHistories(ctx, func.scenario, func.artifacts);
   return [
     ...previous.slice(0, -1),
     {
@@ -33,27 +31,29 @@ export const transformTestCorrectHistories = async <
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.TEST_CORRECT,
     },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        ${previous.at(-1)!.text}
+    previous.at(-1)!,
+    ...failures.map(
+      (f) =>
+        ({
+          id: v4(),
+          created_at: new Date().toISOString(),
+          type: "assistantMessage",
+          text: StringUtil.trim`
+            ## Generated TypeScript Code
 
-        ## Generated TypeScript Code
+            \`\`\`typescript
+            ${f.function.script}
+            \`\`\`
 
-        \`\`\`typescript
-        ${func.script}
-        \`\`\`
+            ## Compile Errors
 
-        ## Compile Errors
-        
-        Fix the compilation error in the provided code.
+            Fix the compilation error in the provided code.
 
-        \`\`\`json
-        ${JSON.stringify(failure.diagnostics)}
-        \`\`\`
-      `,
-    },
+            \`\`\`json
+            ${JSON.stringify(f.failure.diagnostics)}
+            \`\`\`
+          `,
+        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ),
   ];
 };

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

@@ -48,7 +48,7 @@ export const transformTestScenarioHistories = (
     {
       id: v7(),
       created_at: new Date().toISOString(),
-      type: "systemMessage",
+      type: "assistantMessage",
       text: StringUtil.trim`
         # Operations
 
@@ -73,17 +73,18 @@ export const transformTestScenarioHistories = (
         )}
         \`\`\`
       `,
-    } satisfies IAgenticaHistoryJson.ISystemMessage,
+    } satisfies IAgenticaHistoryJson.IAssistantMessage,
     {
       id: v7(),
       created_at: new Date().toISOString(),
-      type: "systemMessage",
+      type: "assistantMessage",
       text: StringUtil.trim`
         # Included in Test Plan
 
         Below are the endpoints that have been included in the test plan.
         Each endpoint shows its authentication requirements and related authentication APIs.
-        When testing endpoints that require authentication, ensure you include the corresponding join/login operations in your test scenario to establish proper authentication context.
+        When testing endpoints that require authentication, ensure you include the corresponding 
+        join/login operations in your test scenario to establish proper authentication context.
 
         ${include
           .map((el, i) => {
@@ -121,6 +122,6 @@ export const transformTestScenarioHistories = (
           .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
           .join("\n")}
       `,
-    } satisfies IAgenticaHistoryJson.ISystemMessage,
+    } satisfies IAgenticaHistoryJson.IAssistantMessage,
   ];
 };

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

@@ -83,9 +83,28 @@ export async function transformTestWriteHistories<
 
         ## External Definitions
 
+        Here is the external declaration files (d.ts) you can reference.
+
         \`\`\`json
         ${JSON.stringify(await getTestExternalDeclarations(ctx))}
         \`\`\`
+
+        ## Template Code
+
+        Here is the template e2e test code what you must follow.
+
+        You're only allowed to modify the "<SCENARIO DESCRIPTION HERE>" and
+        code inside the function block marked as "// <E2E TEST CODE HERE>". 
+        Change the template code by writing your scenario description to the 
+        comment, and filling your implementation logic into the function.
+
+        Note that, you don't need to add any "import" statement more than
+        this template code. Everything you need is already imported, so
+        make your implementation code in the import scope.
+
+        \`\`\`typescript
+        ${artifacts.template}
+        \`\`\`
       `,
     },
   ];

package/src/orchestrate/test/orchestrateTest.ts

@@ -68,6 +68,12 @@ export const orchestrateTest =
       ctx,
       written,
     );
+    // for (const c of corrects)
+    //   if (c.result.type !== "success")
+    //     c.file.content = c.file.content
+    //       .split("\n")
+    //       .map((s) => `// ${s}`)
+    //       .join("\n");
 
     // DO COMPILE
     const compiler: IAutoBeCompiler = await ctx.compiler();