@autobe/agent 0.18.0 → 0.20.0

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

@@ -7,7 +7,7 @@ import {
   OpenApi,
 } from "@samchon/openapi";
 import typia from "typia";
-import { v4 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
@@ -18,7 +18,7 @@ export function transformTestWriteHistories(
 ): Array<IAgenticaHistoryJson.ISystemMessage> {
   return [
     {
-      id: v4(),
+      id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.TEST_WRITE.replace(
@@ -27,7 +27,7 @@ export function transformTestWriteHistories(
       ).replaceAll("{{FUNCTION_NAME}}", scenario.functionName),
     },
     {
-      id: v4(),
+      id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: StringUtil.trim`

package/src/orchestrate/test/orchestrateTest.ts

@@ -8,10 +8,11 @@ import {
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
-import { v4 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { orchestrateTestCorrect } from "./orchestrateTestCorrect";
 import { orchestrateTestScenario } from "./orchestrateTestScenario";
 import { orchestrateTestWrite } from "./orchestrateTestWrite";
@@ -22,19 +23,31 @@ export const orchestrateTest =
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory> => {
+    // PREDICATION
     const start: Date = new Date();
+    const predicate: string | null = predicateStateMessage(ctx.state(), "test");
+    if (predicate !== null)
+      return ctx.assistantMessage({
+        type: "assistantMessage",
+        id: v7(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
     ctx.dispatch({
       type: "testStart",
+      id: v7(),
       created_at: start.toISOString(),
       reason: props.reason,
       step: ctx.state().analyze?.step ?? 0,
     });
 
+    // CHECK OPERATIONS
     const operations: AutoBeOpenApi.IOperation[] =
       ctx.state().interface?.document.operations ?? [];
     if (operations.length === 0)
       return ctx.assistantMessage({
-        id: v4(),
+        id: v7(),
         type: "assistantMessage",
         created_at: start.toISOString(),
         completed_at: new Date().toISOString(),
@@ -51,14 +64,10 @@ export const orchestrateTest =
       ctx,
       scenarios,
     );
-
     const corrects: AutoBeTestValidateEvent[] = await orchestrateTestCorrect(
       ctx,
       written,
     );
-    const success: AutoBeTestValidateEvent[] = corrects.filter(
-      (c) => c.result.type === "success",
-    );
 
     // DO COMPILE
     const compiler: IAutoBeCompiler = await ctx.compiler();
@@ -70,13 +79,14 @@ export const orchestrateTest =
               dbms: "sqlite",
             }),
           ).filter(([key]) => key.endsWith(".ts")),
-          ...success.map((s) => [s.file.location, s.file.content]),
+          ...corrects.map((s) => [s.file.location, s.file.content]),
         ]),
       });
     return ctx.dispatch({
       type: "testComplete",
+      id: v7(),
       created_at: new Date().toISOString(),
-      files: success.map((s) => s.file),
+      files: corrects.map((s) => s.file),
       compiled,
       step: ctx.state().interface?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -4,12 +4,15 @@ import {
   IAutoBeCompiler,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
 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 { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { completeTestCode } from "./compile/completeTestCode";
 import { transformTestCorrectHistories } from "./histories/transformTestCorrectHistories";
 import { IAutoBeTestCorrectApplication } from "./structures/IAutoBeTestCorrectApplication";
@@ -22,31 +25,32 @@ export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
   writeResult: IAutoBeTestWriteResult[],
   life: number = 4,
 ): Promise<AutoBeTestValidateEvent[]> => {
-  const result: Array<AutoBeTestValidateEvent | null> = await Promise.all(
-    writeResult.map(async (w) => {
-      try {
-        const event: AutoBeTestValidateEvent = await compile(ctx, {
-          artifacts: w.artifacts,
-          scenario: w.scenario,
-          location: w.event.location,
-          script: w.event.final,
-        });
-        return predicate(
-          ctx,
-          {
+  const result: Array<AutoBeTestValidateEvent | null> =
+    await executeCachedBatch(
+      writeResult.map((w) => async () => {
+        try {
+          const event: AutoBeTestValidateEvent = await compile(ctx, {
             artifacts: w.artifacts,
             scenario: w.scenario,
             location: w.event.location,
             script: w.event.final,
-          },
-          event,
-          life,
-        );
-      } catch {
-        return null;
-      }
-    }),
-  );
+          });
+          return await predicate(
+            ctx,
+            {
+              artifacts: w.artifacts,
+              scenario: w.scenario,
+              location: w.event.location,
+              script: w.event.final,
+            },
+            event,
+            life,
+          );
+        } catch {
+          return null;
+        }
+      }),
+    );
   return result.filter((r) => r !== null);
 };
 
@@ -64,6 +68,7 @@ const compile = async <Model extends ILlmSchema.Model>(
   });
   return {
     type: "testValidate",
+    id: v7(),
     file: {
       scenario: func.scenario,
       location: func.location,
@@ -83,7 +88,7 @@ const predicate = async <Model extends ILlmSchema.Model>(
 ): Promise<AutoBeTestValidateEvent> => {
   if (event.result.type === "failure") ctx.dispatch(event);
   return event.result.type === "failure"
-    ? correct(ctx, content, event, life - 1)
+    ? await correct(ctx, content, event, life - 1)
     : event;
 };
 
@@ -110,8 +115,12 @@ const correct = async <Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
-    message:
-      "Fix the `AutoBeTest.IFunction` data to resolve the compilation error.",
+    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.
+    `,
   });
   if (pointer.value === null) throw new Error("Failed to modify test code.");
 
@@ -120,6 +129,7 @@ const correct = async <Model extends ILlmSchema.Model>(
 
   ctx.dispatch({
     type: "testCorrect",
+    id: v7(),
     created_at: new Date().toISOString(),
     file: validate.file,
     result: validate.result,

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -1,16 +1,23 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeOpenApi, AutoBeTestScenario } from "@autobe/interface";
-import { AutoBeEndpointComparator } from "@autobe/utils";
+import {
+  AutoBeInterfaceAuthorization,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeTestScenario,
+} from "@autobe/interface";
+import { AutoBeEndpointComparator, MapUtil, StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { HashMap, IPointer, Pair } from "tstl";
 import typia from "typia";
+import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
-import { IProgress } from "../internal/IProgress";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformTestScenarioHistories } from "./histories/transformTestScenarioHistories";
 import { IAutoBeTestScenarioApplication } from "./structures/IAutoBeTestScenarioApplication";
+import { IAutoBeTestScenarioAuthorizationRole } from "./structures/IAutoBeTestScenarioAuthorizationRole";
 
 export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -38,6 +45,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
       AutoBeEndpointComparator.hashCode,
       AutoBeEndpointComparator.equals,
     );
+
   const endpointNotFound: string = [
     `You have to select one of the endpoints below`,
     "",
@@ -46,7 +54,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     ...operations.map((op) => `\`${op.method}\` | \`${op.path}\``).join("\n"),
   ].join("\n");
 
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: operations.length,
     completed: 0,
   };
@@ -58,18 +66,18 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
       array: include,
       capacity: 5,
     });
-    await Promise.all(
-      matrix.map(async (include) => {
+    await executeCachedBatch(
+      matrix.map((include) => async (promptCacheKey) => {
         exclude.push(
-          ...(await divideAndConquer(
-            ctx,
+          ...(await divideAndConquer(ctx, {
             dict,
             endpointNotFound,
-            operations,
+            entire: operations,
             include,
-            exclude.map((x) => x.endpoint),
+            exclude: exclude.map((x) => x.endpoint),
             progress,
-          )),
+            promptCacheKey,
+          })),
         );
       }),
     );
@@ -100,34 +108,49 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
 
 const divideAndConquer = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>,
-  endpointNotFound: string,
-  entire: AutoBeOpenApi.IOperation[],
-  include: AutoBeOpenApi.IOperation[],
-  exclude: AutoBeOpenApi.IEndpoint[],
-  progress: IProgress,
-) => {
+  props: {
+    dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
+    endpointNotFound: string;
+    entire: AutoBeOpenApi.IOperation[];
+    include: AutoBeOpenApi.IOperation[];
+    exclude: AutoBeOpenApi.IEndpoint[];
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
+): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> => {
   const pointer: IPointer<IAutoBeTestScenarioApplication.IScenarioGroup[]> = {
     value: [],
   };
+
+  const authorizations: AutoBeInterfaceAuthorization[] =
+    ctx.state().interface?.authorizations ?? [];
+
   const { tokenUsage } = await ctx.conversate({
     source: "testScenarios",
-    histories: transformTestScenarioHistories(entire, include, exclude),
+    histories: transformTestScenarioHistories(
+      ctx.state(),
+      props.entire,
+      props.include,
+      props.exclude,
+    ),
     controller: createController({
       model: ctx.model,
-      endpointNotFound,
-      dict,
+      endpointNotFound: props.endpointNotFound,
+      dict: props.dict,
+      authorizations,
       build: (next) => {
         pointer.value ??= [];
         pointer.value.push(...next.scenarioGroups);
       },
     }),
     enforceFunctionCall: true,
+    promptCacheKey: props.promptCacheKey,
     message: `Create e2e test scenarios.`,
   });
   if (pointer.value.length === 0) return [];
   ctx.dispatch({
     type: "testScenarios",
+    id: v7(),
     tokenUsage,
     scenarios: pointer.value
       .map((v) =>
@@ -142,8 +165,8 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
         ),
       )
       .flat(),
-    completed: ++progress.completed,
-    total: progress.total,
+    completed: ++props.progress.completed,
+    total: props.progress.total,
     step: ctx.state().interface?.step ?? 0,
     created_at: new Date().toISOString(),
   });
@@ -154,6 +177,7 @@ function 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> {
   assertSchemaModel(props.model);
@@ -166,19 +190,8 @@ function createController<Model extends ILlmSchema.Model>(props: {
     if (result.success === false) return result;
 
     // merge to unique scenario groups
-    const scenarioGroups: IAutoBeTestScenarioApplication.IScenarioGroup[] = [];
-    result.data.scenarioGroups.forEach((sg) => {
-      const created = scenarioGroups.find(
-        (el) =>
-          el.endpoint.method === sg.endpoint.method &&
-          el.endpoint.path === sg.endpoint.path,
-      );
-      if (created) {
-        created.scenarios.push(...sg.scenarios);
-      } else {
-        scenarioGroups.push(sg);
-      }
-    });
+    const scenarioGroups: IAutoBeTestScenarioApplication.IScenarioGroup[] =
+      uniqueScenarioGroups(result.data.scenarioGroups);
 
     // validate endpoints
     const errors: IValidation.IError[] = [];
@@ -202,6 +215,125 @@ function createController<Model extends ILlmSchema.Model>(props: {
         });
       });
     });
+
+    // Authentication Correction
+    const entireRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
+      new Map();
+    for (const authorization of props.authorizations) {
+      for (const op of authorization.operations) {
+        if (op.authorizationType === null) continue;
+        const value: IAutoBeTestScenarioAuthorizationRole = MapUtil.take(
+          entireRoles,
+          authorization.role,
+          () => ({
+            name: authorization.role,
+            join: null,
+            login: null,
+          }),
+        );
+        if (op.authorizationType === "join") value.join = op;
+        else if (op.authorizationType === "login") value.login = op;
+      }
+    }
+
+    scenarioGroups.forEach((group) => {
+      if (props.dict.has(group.endpoint) === false) return;
+
+      const operation: AutoBeOpenApi.IOperation = props.dict.get(
+        group.endpoint,
+      );
+      group.scenarios.forEach((scenario) => {
+        // gathere authorization roles
+        const localRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
+          new Map();
+        const add = (operation: AutoBeOpenApi.IOperation) => {
+          const role: string | null = operation.authorizationRole;
+          if (role === null) return;
+          MapUtil.take(localRoles, role, () => ({
+            name: role,
+            join: null,
+            login: null,
+          }));
+        };
+        add(operation);
+        scenario.dependencies.forEach((d) => {
+          if (props.dict.has(d.endpoint) === false) return;
+          const depOperation: AutoBeOpenApi.IOperation = props.dict.get(
+            d.endpoint,
+          );
+          add(depOperation);
+        });
+
+        // Single role case - add join operation
+        if (localRoles.size === 1) {
+          const role: IAutoBeTestScenarioAuthorizationRole = localRoles
+            .values()
+            .next().value!;
+          if (role.join === null) {
+            const joinOperation: AutoBeOpenApi.IOperation | null =
+              entireRoles.get(role.name)?.join ?? null;
+            if (joinOperation === null) throw new Error("Unreachable code");
+
+            scenario.dependencies.push({
+              endpoint: {
+                method: joinOperation.method,
+                path: joinOperation.path,
+              },
+              purpose: StringUtil.trim`
+                Essential authentication prerequisite: 
+                This join operation (${joinOperation.method} ${joinOperation.path}) must be executed before any operations requiring '${role.name}' role authorization. 
+                It establishes the necessary user account and authentication context for the '${role.name}' role, enabling subsequent API calls that depend on this specific authorization level. 
+                Without this join operation, the main scenario endpoint and its dependencies will fail due to insufficient authentication credentials.
+              `,
+            });
+          }
+        }
+
+        // Multiple roles case - add both join and login operations
+        if (localRoles.size > 1) {
+          for (const role of localRoles.values()) {
+            if (role.join === null) {
+              const joinOperation: AutoBeOpenApi.IOperation | null =
+                entireRoles.get(role.name)?.join ?? null;
+              if (joinOperation === null) throw new Error("Unreachable code");
+
+              scenario.dependencies.push({
+                endpoint: {
+                  path: joinOperation.path,
+                  method: joinOperation.method,
+                },
+                purpose: StringUtil.trim`
+                  Multi-actor authentication setup: 
+                  This join operation (${joinOperation.method} ${joinOperation.path}) is required to establish a '${role.name}' role user account in the system. 
+                  This scenario involves multiple authorization roles, requiring separate user accounts for each role to properly test cross-role interactions and authorization boundaries. 
+                  The join operation creates the foundational user identity that will be used throughout the test scenario for '${role.name}' specific operations.
+                  This join operation is required for the '${role.name}' role authentication.
+                `,
+              });
+            }
+            if (role.login === null) {
+              const loginOperation: AutoBeOpenApi.IOperation | null =
+                entireRoles.get(role.name)?.login ?? null;
+              if (loginOperation === null) throw new Error("Unreachable code");
+
+              scenario.dependencies.push({
+                endpoint: {
+                  path: loginOperation.path,
+                  method: loginOperation.method,
+                },
+                purpose: StringUtil.trim`
+                  Role switching authentication: 
+                  This login operation (${loginOperation.method} ${loginOperation.path}) enables dynamic user role switching during test execution for the '${role.name}' role. 
+                  In scenarios with multiple actors, the test agent needs to authenticate as different users to simulate real-world multi-user interactions. 
+                  This login operation ensures proper session management and authorization context switching, allowing the test to validate permissions, access controls, and business logic that span across different user roles within a single test scenario.
+                  This login operation may be required for user role swapping between multiple actors.
+                `,
+              });
+            }
+          }
+        }
+      });
+    });
     return errors.length === 0
       ? {
           success: true,
@@ -234,6 +366,17 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
+const uniqueScenarioGroups = (
+  groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
+): IAutoBeTestScenarioApplication.IScenarioGroup[] =>
+  new HashMap(
+    groups.map((g) => new Pair(g.endpoint, g)),
+    AutoBeEndpointComparator.hashCode,
+    AutoBeEndpointComparator.equals,
+  )
+    .toJSON()
+    .map((it) => it.second);
+
 const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioApplication, "chatgpt">({

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -1,5 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeProgressEventBase,
   AutoBeTestScenario,
   AutoBeTestWriteEvent,
   IAutoBeCompiler,
@@ -7,10 +8,11 @@ import {
 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 { IProgress } from "../internal/IProgress";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { completeTestCode } from "./compile/completeTestCode";
 import { getTestScenarioArtifacts } from "./compile/getTestScenarioArtifacts";
 import { transformTestWriteHistories } from "./histories/transformTestWriteHistories";
@@ -22,26 +24,26 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   scenarios: AutoBeTestScenario[],
 ): Promise<IAutoBeTestWriteResult[]> {
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: scenarios.length,
     completed: 0,
   };
-  const result: Array<IAutoBeTestWriteResult | null> = await Promise.all(
+  const result: Array<IAutoBeTestWriteResult | null> = await executeCachedBatch(
     /**
      * Generate test code for each scenario. Maps through plans array to create
      * individual test code implementations. Each scenario is processed to
      * generate corresponding test code and progress events.
      */
-    scenarios.map(async (scenario) => {
+    scenarios.map((scenario) => async (promptCacheKey) => {
       try {
         const artifacts: IAutoBeTestScenarioArtifacts =
           await getTestScenarioArtifacts(ctx, scenario);
-        const event: AutoBeTestWriteEvent = await process(
-          ctx,
+        const event: AutoBeTestWriteEvent = await process(ctx, {
           scenario,
           artifacts,
           progress,
-        );
+          promptCacheKey,
+        });
         ctx.dispatch(event);
         return {
           scenario,
@@ -56,21 +58,16 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
   return result.filter((r) => r !== null);
 }
 
-/**
- * Process function that generates test code for each individual scenario. Takes
- * the AutoBeContext and scenario information as input and uses MicroAgentica to
- * generate appropriate test code through LLM interaction.
- *
- * @param ctx - The AutoBeContext containing model, vendor and configuration
- * @param scenario - The test scenario information to generate code for
- * @param artifacts - The artifacts containing the reference files and schemas
- */
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenario: AutoBeTestScenario,
-  artifacts: IAutoBeTestScenarioArtifacts,
-  progress: IProgress,
+  props: {
+    scenario: AutoBeTestScenario;
+    artifacts: IAutoBeTestScenarioArtifacts;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
 ): Promise<AutoBeTestWriteEvent> {
+  const { scenario, artifacts, progress, promptCacheKey } = props;
   const pointer: IPointer<IAutoBeTestWriteApplication.IProps | null> = {
     value: null,
   };
@@ -85,6 +82,7 @@ async function process<Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
+    promptCacheKey,
     message: "Create e2e test functions.",
   });
   if (pointer.value === null) throw new Error("Failed to create test code.");
@@ -93,6 +91,7 @@ async function process<Model extends ILlmSchema.Model>(
   pointer.value.final = await compiler.typescript.beautify(pointer.value.final);
   return {
     type: "testWrite",
+    id: v7(),
     created_at: new Date().toISOString(),
     location: `test/features/api/${pointer.value.domain}/${scenario.functionName}.ts`,
     ...pointer.value,

package/src/orchestrate/test/structures/IAutoBeTestCorrectApplication.ts

@@ -31,7 +31,7 @@ export namespace IAutoBeTestCorrectApplication {
      * AI analyzes the original test scenario, business requirements, and
      * intended functionality without being influenced by compilation errors.
      * This clean analysis establishes a clear understanding of what the test
-     * should accomplish, the expected business workflow, and the correct API
+     * accomplishes, the expected business workflow, and the correct API
      * integration patterns.
      *
      * This step ensures that error correction doesn't lose sight of the
@@ -70,17 +70,18 @@ export namespace IAutoBeTestCorrectApplication {
      * AI generates the first corrected version of the test code based on error
      * analysis and correction strategies. This draft addresses all identified
      * compilation errors while preserving the original business logic and test
-     * workflow. The code must be compilation-error-free and follow all
-     * established conventions.
+     * workflow. The code is compilation-error-free and follows all established
+     * conventions.
      *
      * The implementation incorporates lessons learned from error analysis to
      * produce properly typed, syntactically correct code that maintains the
      * intended test functionality. All type safety requirements and framework
-     * conventions must be followed in this corrected implementation.
+     * conventions are followed in this corrected implementation.
      *
      * Workflow: Error correction → TypeScript implementation → Functional
-     * preservation Critical: Must resolve all compilation errors while
-     * maintaining original test intent
+     * preservation
+     *
+     * DO: Resolve all compilation errors while maintaining original test intent
      */
     draft: string;
 

package/src/orchestrate/test/structures/IAutoBeTestScenarioApplication.ts

@@ -63,7 +63,7 @@ export namespace IAutoBeTestScenarioApplication {
      *
      * ## Naming Convention
      *
-     * MUST use snake_case naming convention.
+     * DO: Use snake_case naming convention.
      *
      * - Must start with `test_api_` prefix (mandatory requirement)
      * - ALWAYS start with business feature, NOT action verbs

package/src/orchestrate/test/structures/IAutoBeTestScenarioAuthorizationRole.ts

@@ -0,0 +1,7 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export interface IAutoBeTestScenarioAuthorizationRole {
+  name: string;
+  join: AutoBeOpenApi.IOperation | null;
+  login: AutoBeOpenApi.IOperation | null;
+}