@autobe/agent 0.17.1 → 0.19.1

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -1,30 +1,25 @@
+import { IAgenticaController } from "@agentica/core";
 import {
-  IAgenticaController,
-  IAgenticaHistoryJson,
-  MicroAgentica,
-} from "@agentica/core";
-import {
+  AutoBeInterfaceAuthorization,
   AutoBeOpenApi,
+  AutoBeProgressEventBase,
   AutoBeTestScenario,
-  AutoBeTestScenarioEvent,
 } from "@autobe/interface";
-import { AutoBeEndpointComparator } from "@autobe/utils";
+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 { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { forceRetry } from "../../utils/forceRetry";
+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>,
-): Promise<AutoBeTestScenarioEvent> {
+): Promise<AutoBeTestScenario[]> {
   const operations: AutoBeOpenApi.IOperation[] =
     ctx.state().interface?.document.operations ?? [];
   if (operations.length === 0) {
@@ -48,6 +43,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`,
     "",
@@ -56,6 +52,10 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     ...operations.map((op) => `\`${op.method}\` | \`${op.path}\``).join("\n"),
   ].join("\n");
 
+  const progress: AutoBeProgressEventBase = {
+    total: operations.length,
+    completed: 0,
+  };
   const exclude: IAutoBeTestScenarioApplication.IScenarioGroup[] = [];
   let include: AutoBeOpenApi.IOperation[] = Array.from(operations);
 
@@ -67,15 +67,14 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     await Promise.all(
       matrix.map(async (include) => {
         exclude.push(
-          ...(await forceRetry(() =>
-            execute(
-              ctx,
-              dict,
-              endpointNotFound,
-              operations,
-              include,
-              exclude.map((x) => x.endpoint),
-            ),
+          ...(await divideAndConquer(
+            ctx,
+            dict,
+            endpointNotFound,
+            operations,
+            include,
+            exclude.map((x) => x.endpoint),
+            progress,
           )),
         );
       }),
@@ -93,164 +92,99 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     });
   } while (include.length > 0);
 
-  return {
-    type: "testScenario",
-    step: ctx.state().analyze?.step ?? 0,
-    scenarios: exclude.flatMap((pg) => {
-      return pg.scenarios.map((plan) => {
-        return {
-          endpoint: pg.endpoint,
-          draft: plan.draft,
-          functionName: plan.functionName,
-          dependencies: plan.dependencies,
-        } satisfies AutoBeTestScenario;
-      });
-    }),
-    created_at: new Date().toISOString(),
-  } as AutoBeTestScenarioEvent;
+  return exclude.flatMap((pg) => {
+    return pg.scenarios.map((plan) => {
+      return {
+        endpoint: pg.endpoint,
+        draft: plan.draft,
+        functionName: plan.functionName,
+        dependencies: plan.dependencies,
+      } satisfies AutoBeTestScenario;
+    });
+  });
 }
 
-const execute = async <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.IEndpoint[],
+  include: AutoBeOpenApi.IOperation[],
   exclude: AutoBeOpenApi.IEndpoint[],
+  progress: AutoBeProgressEventBase,
 ) => {
   const pointer: IPointer<IAutoBeTestScenarioApplication.IScenarioGroup[]> = {
     value: [],
   };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
+
+  const authorizations: AutoBeInterfaceAuthorization[] =
+    ctx.state().interface?.authorizations ?? [];
+
+  const { tokenUsage } = await ctx.conversate({
+    source: "testScenarios",
+    histories: transformTestScenarioHistories(
+      ctx.state(),
+      entire,
+      include,
+      exclude,
+    ),
+    controller: createController({
+      model: ctx.model,
+      endpointNotFound,
+      dict,
+      authorizations,
+      build: (next) => {
+        pointer.value ??= [];
+        pointer.value.push(...next.scenarioGroups);
       },
-    },
-    histories: createHistoryProperties(entire, include, exclude),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        endpointNotFound,
-        dict,
-        build: (next) => {
-          pointer.value ??= [];
-          pointer.value.push(...next.scenarioGroups);
-        },
-      }),
-    ],
+    }),
+    enforceFunctionCall: true,
+    message: `Create e2e test scenarios.`,
   });
-  enforceToolCall(agentica);
-
-  await agentica.conversate(`create test scenarios.`).finally(() => {
-    const tokenUsage = agentica.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["test"]);
+  if (pointer.value.length === 0) return [];
+  ctx.dispatch({
+    type: "testScenarios",
+    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: ++progress.completed,
+    total: progress.total,
+    step: ctx.state().interface?.step ?? 0,
+    created_at: new Date().toISOString(),
   });
-  if (pointer.value.length === 0) {
-    console.error("Failed to create test plans. No function called.");
-    return [];
-    // @todo
-    // throw new Error("Failed to create test plans.");
-  }
   return pointer.value;
 };
 
-const createHistoryProperties = (
-  entire: AutoBeOpenApi.IOperation[],
-  include: Pick<AutoBeOpenApi.IOperation, "method" | "path">[],
-  exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[],
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => [
-  {
-    id: v4(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: AutoBeSystemPromptConstant.TEST_SCENARIO,
-  } satisfies IAgenticaHistoryJson.ISystemMessage,
-  {
-    id: v4(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: [
-      "# Operations",
-      "Below are the full operations. Please refer to this.",
-      "Your role is to draft all test cases for each given Operation.",
-      "It is also permissible to write multiple test codes on a single endpoint.",
-      "However, rather than meaningless tests, business logic tests should be written and an E2E test situation should be assumed.",
-      "",
-      "Please carefully analyze each operation to identify all dependencies required for testing.",
-      "For example, if you want to test liking and then deleting a post,",
-      "you might think to test post creation, liking, and unlike operations.",
-      "However, even if not explicitly mentioned, user registration and login are essential prerequisites.",
-      "Pay close attention to IDs and related values in the API,",
-      "and ensure you identify all dependencies between endpoints.",
-      "",
-      "```json",
-      JSON.stringify(
-        entire.map((el) => ({
-          ...el,
-          specification: undefined,
-        })),
-      ),
-      "```",
-    ].join("\n"),
-  } satisfies IAgenticaHistoryJson.ISystemMessage,
-  {
-    id: v4(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: [
-      "# Included in Test Plan",
-      include
-        .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
-        .join("\n"),
-      "",
-      "# 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.",
-      exclude
-        .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
-        .join("\n"),
-    ].join("\n"),
-  } satisfies IAgenticaHistoryJson.ISystemMessage,
-];
-
-function createApplication<Model extends ILlmSchema.Model>(props: {
+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);
 
-  const application: ILlmApplication<Model> = collection[
-    props.model
-  ] as unknown as ILlmApplication<Model>;
-
-  application.functions[0].validate = (next: unknown): IValidation => {
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeTestScenarioApplication.IProps> => {
     const result: IValidation<IAutoBeTestScenarioApplication.IProps> =
       typia.validate<IAutoBeTestScenarioApplication.IProps>(next);
     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[] = [];
@@ -274,17 +208,145 @@ function createApplication<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,
-          data: scenarioGroups,
+          data: {
+            scenarioGroups,
+          },
         }
       : {
           success: false,
-          data: scenarioGroups,
+          data: {
+            scenarioGroups,
+          },
           errors,
         };
   };
+  const application: ILlmApplication<Model> = collection[
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "Make test plans",
@@ -297,21 +359,32 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeTestScenarioApplication,
-  "claude",
-  {
-    reference: true;
-  }
->();
+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: typia.llm.application<
-    IAutoBeTestScenarioApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeTestScenarioApplication, "chatgpt">({
+      validate: {
+        makeScenario: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeTestScenarioApplication, "claude">({
+      validate: {
+        makeScenario: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeTestScenarioApplication.IProps>;

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -1,5 +1,6 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeProgressEventBase,
   AutoBeTestScenario,
   AutoBeTestWriteEvent,
   IAutoBeCompiler,
@@ -10,22 +11,21 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { forceRetry } from "../../utils/forceRetry";
 import { completeTestCode } from "./compile/completeTestCode";
 import { getTestScenarioArtifacts } from "./compile/getTestScenarioArtifacts";
+import { transformTestWriteHistories } from "./histories/transformTestWriteHistories";
 import { IAutoBeTestScenarioArtifacts } from "./structures/IAutoBeTestScenarioArtifacts";
 import { IAutoBeTestWriteApplication } from "./structures/IAutoBeTestWriteApplication";
 import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
-import { transformTestWriteHistories } from "./transformTestWriteHistories";
 
 export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   scenarios: AutoBeTestScenario[],
 ): Promise<IAutoBeTestWriteResult[]> {
-  const start: Date = new Date();
-  let complete: number = 0;
-
+  const progress: AutoBeProgressEventBase = {
+    total: scenarios.length,
+    completed: 0,
+  };
   const result: Array<IAutoBeTestWriteResult | null> = await Promise.all(
     /**
      * Generate test code for each scenario. Maps through plans array to create
@@ -34,31 +34,20 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
      */
     scenarios.map(async (scenario) => {
       try {
-        const r = await forceRetry(async () => {
-          const artifacts: IAutoBeTestScenarioArtifacts =
-            await getTestScenarioArtifacts(ctx, scenario);
-          const result: IAutoBeTestWriteApplication.IProps = await process(
-            ctx,
-            scenario,
-            artifacts,
-          );
-          const event: AutoBeTestWriteEvent = {
-            type: "testWrite",
-            created_at: start.toISOString(),
-            location: `test/features/api/${result.domain}/${scenario.functionName}.ts`,
-            ...result,
-            completed: ++complete,
-            total: scenarios.length,
-            step: ctx.state().interface?.step ?? 0,
-          };
-          ctx.dispatch(event);
-          return {
-            scenario,
-            artifacts,
-            event,
-          };
-        });
-        return r;
+        const artifacts: IAutoBeTestScenarioArtifacts =
+          await getTestScenarioArtifacts(ctx, scenario);
+        const event: AutoBeTestWriteEvent = await process(
+          ctx,
+          scenario,
+          artifacts,
+          progress,
+        );
+        ctx.dispatch(event);
+        return {
+          scenario,
+          artifacts,
+          event,
+        };
       } catch {
         return null;
       }
@@ -75,48 +64,46 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
  * @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
- * @returns Promise resolving to IAutoBeTestWriteApplication.IProps containing
- *   the generated test code
  */
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   scenario: AutoBeTestScenario,
   artifacts: IAutoBeTestScenarioArtifacts,
-): Promise<IAutoBeTestWriteApplication.IProps> {
+  progress: AutoBeProgressEventBase,
+): Promise<AutoBeTestWriteEvent> {
   const pointer: IPointer<IAutoBeTestWriteApplication.IProps | null> = {
     value: null,
   };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-    },
+  const { tokenUsage } = await ctx.conversate({
+    source: "testWrite",
     histories: transformTestWriteHistories(scenario, artifacts),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        artifacts,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  await agentica.conversate("Create e2e test functions.").finally(() => {
-    const tokenUsage = agentica.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["test"]);
+    controller: createController({
+      model: ctx.model,
+      artifacts,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Create e2e test functions.",
   });
   if (pointer.value === null) throw new Error("Failed to create test code.");
 
   const compiler: IAutoBeCompiler = await ctx.compiler();
   pointer.value.final = await compiler.typescript.beautify(pointer.value.final);
-  return pointer.value;
+  return {
+    type: "testWrite",
+    created_at: new Date().toISOString(),
+    location: `test/features/api/${pointer.value.domain}/${scenario.functionName}.ts`,
+    ...pointer.value,
+    tokenUsage,
+    completed: ++progress.completed,
+    total: progress.total,
+    step: ctx.state().interface?.step ?? 0,
+  } satisfies AutoBeTestWriteEvent;
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   artifacts: IAutoBeTestScenarioArtifacts;
   build: (next: IAutoBeTestWriteApplication.IProps) => void;
@@ -125,7 +112,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "Create Test Code",
@@ -140,19 +127,9 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeTestWriteApplication,
-  "claude",
-  {
-    reference: true;
-  }
->();
+const claude = typia.llm.application<IAutoBeTestWriteApplication, "claude">();
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeTestWriteApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
+  chatgpt: typia.llm.application<IAutoBeTestWriteApplication, "chatgpt">(),
   claude,
   llama: claude,
   deepseek: claude,