@autobe/agent 0.28.0 → 0.29.0

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

@@ -0,0 +1,116 @@
+import { AutoBeInterfaceAuthorization, AutoBeOpenApi } from "@autobe/interface";
+import { MapUtil, StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+import { IAutoBeTestScenarioAuthorizationActor } from "../structures/IAutoBeTestScenarioAuthorizationActor";
+import { getPrerequisites } from "../utils/getPrerequisites";
+
+export const transformTestScenarioHistory = (props: {
+  state: AutoBeState;
+  include: AutoBeOpenApi.IOperation[];
+  exclude: AutoBeOpenApi.IEndpoint[];
+  preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "interfaceOperations" | "interfaceSchemas"
+  >;
+  instruction: string;
+}): IAutoBeOrchestrateHistory => {
+  const document: AutoBeOpenApi.IDocument = props.state.interface!.document!;
+  const authorizations: AutoBeInterfaceAuthorization[] =
+    props.state.interface?.authorizations ?? [];
+  const authorizationActors: Map<
+    string,
+    IAutoBeTestScenarioAuthorizationActor
+  > = new Map();
+
+  for (const authorization of authorizations) {
+    for (const op of authorization.operations) {
+      if (op.authorizationType === null) continue;
+      const value: IAutoBeTestScenarioAuthorizationActor = MapUtil.take(
+        authorizationActors,
+        authorization.name,
+        () => ({
+          name: authorization.name,
+          join: null,
+          login: null,
+        }),
+      );
+      if (op.authorizationType === "join") value.join = op;
+      else if (op.authorizationType === "login") value.login = op;
+    }
+  }
+
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.TEST_SCENARIO,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ## Instructions
+
+          The following e2e-test-specific instructions were extracted from
+          the user's requirements and conversations. These instructions focus
+          exclusively on test-related aspects such as test coverage priorities,
+          specific edge cases to validate, business logic verification strategies,
+          and critical user workflows that must be tested.
+
+          Follow these instructions when generating test scenarios.
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+
+          When instructions contain direct specifications or explicit design decisions,
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+
+          ## 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.
+
+          \`\`\`json
+          ${JSON.stringify(
+            props.include.map((el) => ({
+              method: el.method,
+              path: el.path,
+              prerequisites: getPrerequisites({
+                endpoint: el,
+                document,
+              }),
+              authorizationActors: Array.from(
+                authorizationActors.values(),
+              ).filter((actor) => actor.name === el.authorizationActor),
+            })),
+          )}
+          \`\`\`
+
+          ## Excluded from Test Plan
+
+          These are the endpoints that have already been used in test codes generated as part of a plan group.
+          These endpoints do not need to be tested again.
+          However, it is allowed to reference or depend on these endpoints when writing test codes for other purposes.
+
+          \`\`\`json
+          ${JSON.stringify(props.exclude)}
+          \`\`\`
+
+        `,
+      },
+    ],
+    userMessage: "Design test scenarios for the included endpoints please",
+  };
+};

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

@@ -0,0 +1,85 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+import { IAutoBeTestScenarioApplication } from "../structures/IAutoBeTestScenarioApplication";
+import { getPrerequisites } from "../utils/getPrerequisites";
+
+export function transformTestScenarioReviewHistory(props: {
+  state: AutoBeState;
+  instruction: string;
+  groups: IAutoBeTestScenarioApplication.IScenarioGroup[];
+  preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "interfaceOperations" | "interfaceSchemas"
+  >;
+}): IAutoBeOrchestrateHistory {
+  const document: AutoBeOpenApi.IDocument | undefined =
+    props.state.interface?.document;
+  if (document === undefined) {
+    throw new Error(
+      "Cannot review test scenarios because there are no operations.",
+    );
+  }
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.TEST_SCENARIO,
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.TEST_SCENARIO_REVIEW,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ## Instructions
+
+          The following e2e-test-specific instructions were extracted from
+          the user's requirements and conversations. These instructions focus
+          exclusively on test-related aspects such as test coverage priorities,
+          specific edge cases to validate, business logic verification strategies,
+          and critical user workflows that must be tested.
+
+          Follow these instructions when reviewing test scenarios.
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+
+          When instructions contain direct specifications or explicit design decisions,
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+
+          ## Test Scenario Groups to Review
+
+          Each scenario group includes the target endpoint and its prerequisite endpoints.
+
+          \`\`\`json
+          ${JSON.stringify(
+            props.groups.map((g) => ({
+              ...g,
+              prerequisites: getPrerequisites({
+                document,
+                endpoint: g.endpoint,
+              }),
+            })),
+          )}
+          \`\`\`
+        `,
+      },
+    ],
+    userMessage: "Review the test scenarios please",
+  };
+}

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

@@ -0,0 +1,169 @@
+import { AutoBeTestScenario } from "@autobe/interface";
+import { StringUtil, transformOpenApiDocument } from "@autobe/utils";
+import {
+  HttpMigration,
+  IHttpMigrateApplication,
+  ILlmSchema,
+  OpenApi,
+} from "@samchon/openapi";
+import { Singleton } from "tstl";
+import typia from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { getTestExternalDeclarations } from "../compile/getTestExternalDeclarations";
+import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
+
+export async function transformTestWriteHistory<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    instruction: string;
+    scenario: AutoBeTestScenario;
+    artifacts: IAutoBeTestScenarioArtifacts;
+  },
+): Promise<IAutoBeOrchestrateHistory> {
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: systemPrompt.get(),
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          Here is the list of input material composition.
+
+          Make e2e test functions based on the following information.
+
+          ## Instructions
+
+          The following e2e-test-specific instructions were extracted from
+          the user's requirements and conversations. These instructions focus
+          exclusively on test-related aspects such as test data generation strategies,
+          assertion patterns, error handling approaches, and specific validation logic
+          that should be implemented in the test code.
+
+          Follow these instructions when implementing the e2e test function.
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+
+          When instructions contain direct specifications or explicit design decisions,
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+
+          ## Function Name
+
+          The e2e test function name must be ${JSON.stringify(props.scenario.functionName)}.
+
+          ## Scenario Plan
+
+          Here is the scenario plan what you have to implement.
+
+          \`\`\`json
+          ${JSON.stringify(props.scenario)}
+          \`\`\`
+
+          ## DTO Definitions
+
+          You can use these DTO definitions.
+
+          Never use the DTO definitions that are not listed here.
+
+          ${transformTestWriteHistory.structures(props.artifacts)}
+
+          ## API (SDK) Functions
+
+          You can use these API functions.
+
+          Never use the functions that are not listed here.
+
+          ${transformTestWriteHistory.functional(props.artifacts)}
+
+          ## E2E Mockup Functions
+
+          Just reference, and never follow this code as it is.
+
+          \`\`\`json
+          ${JSON.stringify(props.artifacts.e2e)}
+          \`\`\`
+
+          ## 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
+          ${props.artifacts.template}
+          \`\`\`
+        `,
+      },
+    ],
+    userMessage: `Write e2e test function ${props.scenario.functionName} please`,
+  };
+}
+export namespace transformTestWriteHistory {
+  export function structures(artifacts: IAutoBeTestScenarioArtifacts): string {
+    return StringUtil.trim`
+      ${Object.keys(artifacts.document.components.schemas)
+        .map((k) => `- ${k}`)
+        .join("\n")}
+
+      \`\`\`json
+      ${JSON.stringify(artifacts.dto)}
+      \`\`\`
+    `;
+  }
+
+  export function functional(artifacts: IAutoBeTestScenarioArtifacts): string {
+    const document: OpenApi.IDocument = transformOpenApiDocument(
+      artifacts.document,
+    );
+    const app: IHttpMigrateApplication = HttpMigration.application(document);
+    return StringUtil.trim`
+      Method | Path | Function Accessor
+      -------|------|-------------------
+      ${app.routes
+        .map((r) =>
+          [r.method, r.path, `api.functional.${r.accessor.join(".")}`].join(
+            " | ",
+          ),
+        )
+        .join("\n")}
+
+      \`\`\`json
+      ${JSON.stringify(artifacts.sdk)}
+      \`\`\`
+    `;
+  }
+}
+
+const systemPrompt = new Singleton(() =>
+  AutoBeSystemPromptConstant.TEST_WRITE.replace(
+    "{{AutoBeTestScenario}}",
+    JSON.stringify(typia.llm.parameters<AutoBeTestScenario, "claude">()),
+  ),
+);

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -5,7 +5,6 @@ import {
   IAutoBeCompiler,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -17,7 +16,7 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { orchestrateCommonCorrectCasting } from "../common/orchestrateCommonCorrectCasting";
 import { completeTestCode } from "./compile/completeTestCode";
-import { transformTestCorrectHistories } from "./histories/transformTestCorrectHistories";
+import { transformTestCorrectHistory } from "./histories/transformTestCorrectHistories";
 import { transformTestValidateEvent } from "./histories/transformTestValidateEvent";
 import { orchestrateTestCorrectInvalidRequest } from "./orchestrateTestCorrectInvalidRequest";
 import { IAutoBeTestCorrectApplication } from "./structures/IAutoBeTestCorrectApplication";
@@ -33,6 +32,7 @@ export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
 ): Promise<AutoBeTestValidateEvent[]> => {
   const result: Array<AutoBeTestValidateEvent | null> =
     await executeCachedBatch(
+      ctx,
       props.functions.map((w) => async (promptCacheKey) => {
         try {
           const compile = (script: string) =>
@@ -154,17 +154,6 @@ const correct = async <Model extends ILlmSchema.Model>(
   };
   const { metric, tokenUsage } = await ctx.conversate({
     source: "testCorrect",
-    histories: await transformTestCorrectHistories(ctx, {
-      instruction: props.instruction,
-      function: props.function,
-      failures: [
-        ...props.failures,
-        {
-          function: props.function,
-          failure: props.validate.result,
-        },
-      ],
-    }),
     controller: createController({
       model: ctx.model,
       functionName: props.function.scenario.functionName,
@@ -174,13 +163,18 @@ const correct = async <Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
-    message: StringUtil.trim`
-      Fix the AutoBeTest.IFunction data to resolve the compilation error.
-
-      You don't need to explain me anything, but just fix it immediately
-      without any hesitation, explanation, and questions.
-    `,
     promptCacheKey: props.promptCacheKey,
+    ...(await transformTestCorrectHistory(ctx, {
+      instruction: props.instruction,
+      function: props.function,
+      failures: [
+        ...props.failures,
+        {
+          function: props.function,
+          failure: props.validate.result,
+        },
+      ],
+    })),
   });
   if (pointer.value === null) throw new Error("Failed to correct test code.");
 

package/src/orchestrate/test/orchestrateTestCorrectInvalidRequest.ts

@@ -2,7 +2,6 @@ import {
   AutoBeTestCorrectEvent,
   AutoBeTestValidateEvent,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import {
   ILlmApplication,
   ILlmController,
@@ -17,7 +16,7 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { completeTestCode } from "./compile/completeTestCode";
-import { transformTestCorrectInvalidRequestHistories } from "./histories/transformTestCorrectInvalidRequestHistories";
+import { transformTestCorrectInvalidRequestHistory } from "./histories/transformTestCorrectInvalidRequestHistory";
 import { IAutoBeTestCorrectInvalidRequestApplication } from "./structures/IAutoBeTestCorrectInvalidRequestApplication";
 import { IAutoBeTestFunction } from "./structures/IAutoBeTestFunction";
 
@@ -65,10 +64,6 @@ const correct = async <Model extends ILlmSchema.Model>(
   };
   const { metric, tokenUsage } = await ctx.conversate({
     source: "testCorrect",
-    histories: await transformTestCorrectInvalidRequestHistories(
-      null!,
-      event.result.diagnostics,
-    ),
     controller: createController({
       model: ctx.model,
       functionName: write.scenario.functionName,
@@ -80,12 +75,10 @@ const correct = async <Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
-    message: StringUtil.trim`
-      Fix the AutoBeTest.IFunction data to resolve the compilation error.
-
-      You don't need to explain me anything, but just fix or give it up
-      immediately without any hesitation, explanation, and questions.
-    `,
+    ...transformTestCorrectInvalidRequestHistory(
+      null!,
+      event.result.diagnostics,
+    ),
   });
   if (pointer.value === null) throw new Error("Failed to correct test code.");
   else if (pointer.value === false) return event; // other's responsibility