@autobe/agent 0.28.1 → 0.29.1

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -1,5 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeEventSource,
   AutoBeInterfaceAuthorization,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
@@ -11,7 +12,7 @@ import {
   StringUtil,
 } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
-import { HashMap, IPointer, Pair } from "tstl";
+import { HashMap, HashSet, IPointer, Pair } from "tstl";
 import typia from "typia";
 import { NamingConvention } from "typia/lib/utils/NamingConvention";
 import { v7 } from "uuid";
@@ -21,16 +22,17 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformTestScenarioHistories } from "./histories/transformTestScenarioHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformTestScenarioHistory } from "./histories/transformTestScenarioHistory";
 import { orchestrateTestScenarioReview } from "./orchestrateTestScenarioReview";
 import { IAutoBeTestScenarioApplication } from "./structures/IAutoBeTestScenarioApplication";
 import { IAutoBeTestScenarioAuthorizationActor } from "./structures/IAutoBeTestScenarioAuthorizationActor";
+import { getPrerequisites } from "./utils/getPrerequisites";
 
-export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
+export const orchestrateTestScenario = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   instruction: string,
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
-): Promise<AutoBeTestScenario[]> {
+): Promise<AutoBeTestScenario[]> => {
   const document: AutoBeOpenApi.IDocument | undefined =
     ctx.state().interface?.document;
   if (document === undefined) {
@@ -80,15 +82,15 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
   do {
     const matrix: AutoBeOpenApi.IOperation[][] = divideArray({
       array: include,
-      capacity: capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
+      capacity: AutoBeConfigConstant.INTERFACE_CAPACITY,
     });
     await executeCachedBatch(
+      ctx,
       matrix.map((include) => async (promptCacheKey) => {
         exclude.push(
           ...(await divideAndConquer(ctx, {
             dict,
             endpointNotFound,
-            document,
             include,
             exclude: exclude.map((x) => x.endpoint),
             progress,
@@ -124,14 +126,13 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
       } satisfies AutoBeTestScenario;
     });
   });
-}
+};
 
 const divideAndConquer = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
     dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
     endpointNotFound: string;
-    document: AutoBeOpenApi.IDocument;
     include: AutoBeOpenApi.IOperation[];
     exclude: AutoBeOpenApi.IEndpoint[];
     progress: AutoBeProgressEventBase;
@@ -140,27 +141,74 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
     instruction: string;
   },
 ): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> => {
-  const pointer: IPointer<IAutoBeTestScenarioApplication.IScenarioGroup[]> = {
-    value: [],
-  };
+  try {
+    return await process(ctx, props);
+  } catch {
+    return [];
+  }
+};
+
+const process = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
+    endpointNotFound: string;
+    include: AutoBeOpenApi.IOperation[];
+    exclude: AutoBeOpenApi.IEndpoint[];
+    progress: AutoBeProgressEventBase;
+    reviewProgress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
+): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> => {
   const authorizations: AutoBeInterfaceAuthorization[] =
     ctx.state().interface?.authorizations ?? [];
-
-  try {
-    const { metric, tokenUsage } = await ctx.conversate({
-      source: "testScenario",
-      histories: transformTestScenarioHistories({
-        state: ctx.state(),
-        document: props.document,
-        include: props.include,
-        exclude: props.exclude,
-        instruction: props.instruction,
-      }),
+  const document: AutoBeOpenApi.IDocument = ctx.state().interface!.document!;
+  const preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "interfaceOperations" | "interfaceSchemas"
+  > = new AutoBePreliminaryController({
+    application: typia.json.application<IAutoBeTestScenarioApplication>(),
+    source: SOURCE,
+    kinds: ["analysisFiles", "interfaceOperations", "interfaceSchemas"],
+    state: ctx.state(),
+    local: {
+      interfaceOperations: (() => {
+        const unique: HashSet<AutoBeOpenApi.IEndpoint> = new HashSet(
+          AutoBeOpenApiEndpointComparator.hashCode,
+          AutoBeOpenApiEndpointComparator.equals,
+        );
+        for (const op of props.include) {
+          unique.insert({ method: op.method, path: op.path });
+          for (const pr of getPrerequisites({
+            document,
+            endpoint: op,
+          }))
+            unique.insert(pr.endpoint);
+        }
+        return unique
+          .toJSON()
+          .map((endpoint) =>
+            document.operations.find(
+              (op) =>
+                op.method === endpoint.method && op.path === endpoint.path,
+            ),
+          )
+          .filter((op) => op !== undefined);
+      })(),
+    },
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeTestScenarioApplication.IScenarioGroup[]> = {
+      value: [],
+    };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
       controller: createController({
         model: ctx.model,
         endpointNotFound: props.endpointNotFound,
         dict: props.dict,
         authorizations,
+        preliminary,
         build: (next) => {
           next.scenarioGroups.forEach((sg) =>
             sg.scenarios.forEach((s) => {
@@ -173,54 +221,66 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
       }),
       enforceFunctionCall: true,
       promptCacheKey: props.promptCacheKey,
-      message: `Create e2e test scenarios.`,
-    });
-    if (pointer.value.length === 0) return [];
-
-    props.progress.total = Math.max(
-      props.progress.total,
-      (props.progress.completed += pointer.value.length),
-    );
-    ctx.dispatch({
-      type: "testScenario",
-      id: v7(),
-      metric,
-      tokenUsage,
-      scenarios: pointer.value
-        .map((v) =>
-          v.scenarios.map(
-            (s) =>
-              ({
-                endpoint: v.endpoint,
-                draft: s.draft,
-                functionName: s.functionName,
-                dependencies: s.dependencies,
-              }) satisfies AutoBeTestScenario,
-          ),
-        )
-        .flat(),
-      completed: props.progress.completed,
-      total: props.progress.total,
-      step: ctx.state().interface?.step ?? 0,
-      created_at: new Date().toISOString(),
-    });
-    return await orchestrateTestScenarioReview(ctx, {
-      instruction: props.instruction,
-      groups: pointer.value,
-      progress: props.reviewProgress,
+      ...transformTestScenarioHistory({
+        state: ctx.state(),
+        include: props.include,
+        exclude: props.exclude,
+        instruction: props.instruction,
+        preliminary,
+      }),
     });
-  } catch {
-    return [];
-  }
+    if (pointer.value !== null) {
+      if (pointer.value.length === 0) return out(result)([]);
+      props.progress.total = Math.max(
+        props.progress.total,
+        (props.progress.completed += pointer.value.length),
+      );
+      ctx.dispatch({
+        type: SOURCE,
+        id: v7(),
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        scenarios: pointer.value
+          .map((v) =>
+            v.scenarios.map(
+              (s) =>
+                ({
+                  endpoint: v.endpoint,
+                  draft: s.draft,
+                  functionName: s.functionName,
+                  dependencies: s.dependencies,
+                }) satisfies AutoBeTestScenario,
+            ),
+          )
+          .flat(),
+        completed: props.progress.completed,
+        total: props.progress.total,
+        step: ctx.state().interface?.step ?? 0,
+        created_at: new Date().toISOString(),
+      });
+      return out(result)(
+        await orchestrateTestScenarioReview(ctx, {
+          preliminary,
+          instruction: props.instruction,
+          groups: pointer.value,
+          progress: props.reviewProgress,
+        }),
+      );
+    }
+    return out(result)(null);
+  });
 };
 
-function createController<Model extends ILlmSchema.Model>(props: {
+const createController = <Model extends ILlmSchema.Model>(props: {
   model: Model;
   endpointNotFound: string;
   dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
   authorizations: AutoBeInterfaceAuthorization[];
-  build: (next: IAutoBeTestScenarioApplication.IProps) => void;
-}): IAgenticaController.IClass<Model> {
+  build: (next: IAutoBeTestScenarioApplication.IComplete) => void;
+  preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "interfaceOperations" | "interfaceSchemas"
+  >;
+}): IAgenticaController.IClass<Model> => {
   assertSchemaModel(props.model);
 
   const validate = (
@@ -229,10 +289,15 @@ function createController<Model extends ILlmSchema.Model>(props: {
     const result: IValidation<IAutoBeTestScenarioApplication.IProps> =
       typia.validate<IAutoBeTestScenarioApplication.IProps>(next);
     if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
 
     // merge to unique scenario groups
     const scenarioGroups: IAutoBeTestScenarioApplication.IScenarioGroup[] =
-      uniqueScenarioGroups(result.data.scenarioGroups);
+      uniqueScenarioGroups(result.data.request.scenarioGroups);
 
     // validate endpoints
     const errors: IValidation.IError[] = [];
@@ -240,7 +305,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
       if (props.dict.has(group.endpoint) === false)
         errors.push({
           value: group.endpoint,
-          path: `$input.scenarioGroups[${i}].endpoint`,
+          path: `$input.request.scenarioGroups[${i}].endpoint`,
           expected: "AutoBeOpenApi.IEndpoint",
           description: props.endpointNotFound,
         });
@@ -249,7 +314,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
           if (props.dict.has(dep.endpoint) === false)
             errors.push({
               value: dep.endpoint,
-              path: `$input.scenarioGroups[${i}].scenarios[${j}].dependencies[${k}].endpoint`,
+              path: `$input.request.scenarioGroups[${i}].scenarios[${j}].dependencies[${k}].endpoint`,
               expected: "AutoBeOpenApi.IEndpoint",
               description: props.endpointNotFound,
             });
@@ -376,17 +441,10 @@ function createController<Model extends ILlmSchema.Model>(props: {
       });
     });
     return errors.length === 0
-      ? {
-          success: true,
-          data: {
-            scenarioGroups,
-          },
-        }
+      ? result
       : {
           success: false,
-          data: {
-            scenarioGroups,
-          },
+          data: result.data,
           errors,
         };
   };
@@ -401,15 +459,15 @@ function createController<Model extends ILlmSchema.Model>(props: {
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Make test plans",
+    name: SOURCE,
     application,
     execute: {
-      makeScenario: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBeTestScenarioApplication,
   };
-}
+};
 
 const uniqueScenarioGroups = (
   groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
@@ -426,19 +484,19 @@ const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioApplication, "chatgpt">({
       validate: {
-        makeScenario: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioApplication, "claude">({
       validate: {
-        makeScenario: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioApplication, "gemini">({
       validate: {
-        makeScenario: validate,
+        process: validate,
       },
     }),
 };
@@ -446,3 +504,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeTestScenarioApplication.IProps>;
+
+const SOURCE = "testScenario" satisfies AutoBeEventSource;

package/src/orchestrate/test/orchestrateTestScenarioReview.ts

@@ -1,5 +1,9 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeProgressEventBase, AutoBeTestScenario } from "@autobe/interface";
+import {
+  AutoBeEventSource,
+  AutoBeProgressEventBase,
+  AutoBeTestScenario,
+} from "@autobe/interface";
 import { AutoBeOpenApiEndpointComparator } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { HashMap, IPointer, Pair } from "tstl";
@@ -8,101 +12,108 @@ import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformTestScenarioReviewHistories } from "./histories/transformTestScenarioReviewHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformTestScenarioReviewHistory } from "./histories/transformTestScenarioReviewHistory";
 import { IAutoBeTestScenarioApplication } from "./structures/IAutoBeTestScenarioApplication";
 import { IAutoBeTestScenarioReviewApplication } from "./structures/IAutoBeTestScenarioReviewApplication";
 
-export async function orchestrateTestScenarioReview<
+export const orchestrateTestScenarioReview = async <
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
   props: {
-    instruction: string;
+    preliminary: AutoBePreliminaryController<
+      "analysisFiles" | "interfaceOperations" | "interfaceSchemas"
+    >;
     groups: IAutoBeTestScenarioApplication.IScenarioGroup[];
     progress: AutoBeProgressEventBase;
+    instruction: string;
   },
-): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> {
-  const res: IAutoBeTestScenarioApplication.IScenarioGroup[] = await review(
-    ctx,
-    props,
-  );
-  return res;
-}
-
-async function review<Model extends ILlmSchema.Model>(
+): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> => {
+  try {
+    return await process(ctx, props);
+  } catch {
+    props.progress.completed += props.groups.length;
+    return props.groups;
+  }
+};
+
+const process = <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
-    instruction: string;
+    preliminary: AutoBePreliminaryController<
+      "analysisFiles" | "interfaceOperations" | "interfaceSchemas"
+    >;
     groups: IAutoBeTestScenarioApplication.IScenarioGroup[];
     progress: AutoBeProgressEventBase;
+    instruction: string;
   },
-): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> {
-  try {
-    const pointer: IPointer<IAutoBeTestScenarioReviewApplication.IProps | null> =
+): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> =>
+  props.preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeTestScenarioReviewApplication.IComplete | null> =
       {
         value: null,
       };
-    const { metric, tokenUsage } = await ctx.conversate({
-      source: "testScenarioReview",
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
       controller: createController({
         model: ctx.model,
-        pointer,
         originalGroups: props.groups,
+        pointer,
+        preliminary: props.preliminary,
       }),
-      histories: transformTestScenarioReviewHistories({
+      enforceFunctionCall: true,
+      ...transformTestScenarioReviewHistory({
         state: ctx.state(),
         groups: props.groups,
         instruction: props.instruction,
+        preliminary: props.preliminary,
       }),
-      enforceFunctionCall: true,
-      message: "Review the Test Scenario.",
     });
-    if (pointer.value === null) {
-      // unreachable
-      throw new Error("Failed to get review result.");
+    if (pointer.value !== null) {
+      props.progress.total = Math.max(
+        props.progress.total,
+        (props.progress.completed += pointer.value.scenarioGroups.length),
+      );
+      ctx.dispatch({
+        type: SOURCE,
+        id: v7(),
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        total: props.progress.total,
+        completed: props.progress.completed,
+        scenarios: pointer.value.scenarioGroups
+          .map((group) => {
+            return group.scenarios.map((s) => {
+              return {
+                ...s,
+                endpoint: group.endpoint,
+              } satisfies AutoBeTestScenario;
+            });
+          })
+          .flat(),
+        step: ctx.state().interface?.step ?? 0,
+        created_at: new Date().toISOString(),
+      });
+      // @todo michael: need to investigate scenario removal more gracefully
+      return out(result)(
+        pointer.value.pass
+          ? // || pointer.value.scenarioGroups.length < props.groups.length
+            props.groups
+          : pointer.value.scenarioGroups,
+      );
     }
+    return out(result)(null);
+  });
 
-    props.progress.total = Math.max(
-      props.progress.total,
-      (props.progress.completed += pointer.value.scenarioGroups.length),
-    );
-
-    ctx.dispatch({
-      type: "testScenarioReview",
-      id: v7(),
-      metric,
-      tokenUsage,
-      total: props.progress.total,
-      completed: props.progress.completed,
-      scenarios: pointer.value.scenarioGroups
-        .map((group) => {
-          return group.scenarios.map((s) => {
-            return {
-              ...s,
-              endpoint: group.endpoint,
-            } satisfies AutoBeTestScenario;
-          });
-        })
-        .flat(),
-      step: ctx.state().interface?.step ?? 0,
-      created_at: new Date().toISOString(),
-    });
-    // @todo michael: need to investigate scenario removal more gracefully
-    return pointer.value.pass
-      ? // || pointer.value.scenarioGroups.length < props.groups.length
-        props.groups
-      : pointer.value.scenarioGroups;
-  } catch {
-    props.progress.completed += props.groups.length;
-    return props.groups;
-  }
-}
-
-function createController<Model extends ILlmSchema.Model>(props: {
+const createController = <Model extends ILlmSchema.Model>(props: {
   model: Model;
-  pointer: IPointer<IAutoBeTestScenarioReviewApplication.IProps | null>;
+  pointer: IPointer<IAutoBeTestScenarioReviewApplication.IComplete | null>;
   originalGroups: IAutoBeTestScenarioApplication.IScenarioGroup[];
-}): IAgenticaController.IClass<Model> {
+  preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "interfaceOperations" | "interfaceSchemas"
+  >;
+}): IAgenticaController.IClass<Model> => {
   assertSchemaModel(props.model);
 
   const validate: Validator = (
@@ -111,10 +122,15 @@ function createController<Model extends ILlmSchema.Model>(props: {
     const result: IValidation<IAutoBeTestScenarioReviewApplication.IProps> =
       typia.validate<IAutoBeTestScenarioReviewApplication.IProps>(next);
     if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
 
     // merge to unique scenario groups
     const scenarioGroups: IAutoBeTestScenarioApplication.IScenarioGroup[] =
-      uniqueScenarioGroups(result.data.scenarioGroups);
+      uniqueScenarioGroups(result.data.request.scenarioGroups);
 
     const errors: IValidation.IError[] = [];
 
@@ -136,8 +152,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
         return [...acc, matchingGroup];
       }, []);
-
-    result.data.scenarioGroups = filteredScenarioGroups;
+    result.data.request.scenarioGroups = filteredScenarioGroups;
 
     if (errors.length > 0) {
       return {
@@ -146,7 +161,6 @@ function createController<Model extends ILlmSchema.Model>(props: {
         data: result.data,
       };
     }
-
     return result;
   };
 
@@ -162,15 +176,16 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
   return {
     protocol: "class",
-    name: "Test Scenario Reviewer",
+    name: SOURCE,
     application,
     execute: {
-      review: (input) => {
-        props.pointer.value = input;
+      process: (input) => {
+        if (input.request.type === "complete")
+          props.pointer.value = input.request;
       },
     } satisfies IAutoBeTestScenarioReviewApplication,
   };
-}
+};
 
 const uniqueScenarioGroups = (
   groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
@@ -187,19 +202,19 @@ const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioReviewApplication, "chatgpt">({
       validate: {
-        review: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioReviewApplication, "claude">({
       validate: {
-        review: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioReviewApplication, "gemini">({
       validate: {
-        review: validate,
+        process: validate,
       },
     }),
 };
@@ -207,3 +222,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeTestScenarioReviewApplication.IProps>;
+
+const SOURCE = "testScenarioReview" satisfies AutoBeEventSource;

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -16,7 +16,7 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { completeTestCode } from "./compile/completeTestCode";
 import { getTestScenarioArtifacts } from "./compile/getTestScenarioArtifacts";
-import { transformTestWriteHistories } from "./histories/transformTestWriteHistories";
+import { transformTestWriteHistory } from "./histories/transformTestWriteHistory";
 import { IAutoBeTestScenarioArtifacts } from "./structures/IAutoBeTestScenarioArtifacts";
 import { IAutoBeTestWriteApplication } from "./structures/IAutoBeTestWriteApplication";
 import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
@@ -33,6 +33,7 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
     completed: 0,
   };
   const result: Array<IAutoBeTestWriteResult | null> = await executeCachedBatch(
+    ctx,
     /**
      * Generate test code for each scenario. Maps through plans array to create
      * individual test code implementations. Each scenario is processed to
@@ -79,11 +80,6 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { metric, tokenUsage } = await ctx.conversate({
     source: "testWrite",
-    histories: await transformTestWriteHistories(ctx, {
-      scenario,
-      artifacts,
-      instruction: props.instruction,
-    }),
     controller: createController({
       model: ctx.model,
       functionName: props.scenario.functionName,
@@ -94,7 +90,11 @@ async function process<Model extends ILlmSchema.Model>(
     }),
     enforceFunctionCall: true,
     promptCacheKey,
-    message: "Create e2e test functions.",
+    ...(await transformTestWriteHistory(ctx, {
+      scenario,
+      artifacts,
+      instruction: props.instruction,
+    })),
   });
   if (pointer.value === null) {
     ++progress.completed;