@autobe/agent 0.25.6 → 0.26.0

package/src/orchestrate/interface/orchestrateInterfaceAuthorizations.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeAnalyzeRole,
+  AutoBeAnalyzeActor,
   AutoBeInterfaceAuthorization,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
@@ -24,23 +24,23 @@ export async function orchestrateInterfaceAuthorizations<
   ctx: AutoBeContext<Model>,
   instruction: string,
 ): Promise<AutoBeInterfaceAuthorization[]> {
-  const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
+  const actors: AutoBeAnalyzeActor[] = ctx.state().analyze?.actors ?? [];
   const progress: AutoBeProgressEventBase = {
-    total: roles.length,
+    total: actors.length,
     completed: 0,
   };
   const authorizations: AutoBeInterfaceAuthorization[] =
     await executeCachedBatch(
-      roles.map((role) => async (promptCacheKey) => {
+      actors.map((a) => async (promptCacheKey) => {
         const event: AutoBeInterfaceAuthorizationEvent = await process(ctx, {
-          role,
+          actor: a,
           progress,
           promptCacheKey,
           instruction,
         });
         ctx.dispatch(event);
         return {
-          role: role.name,
+          name: a.name,
           operations: event.operations,
         };
       }),
@@ -53,7 +53,7 @@ async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
     instruction: string;
-    role: AutoBeAnalyzeRole;
+    actor: AutoBeAnalyzeActor;
     progress: AutoBeProgressEventBase;
     promptCacheKey: string;
   },
@@ -67,11 +67,11 @@ async function process<Model extends ILlmSchema.Model>(
     histories: transformInterfaceAuthorizationsHistories({
       state: ctx.state(),
       instruction: props.instruction,
-      role: props.role,
+      actor: props.actor,
     }),
     controller: createController({
       model: ctx.model,
-      role: props.role,
+      actor: props.actor,
       build: (next) => {
         pointer.value = next;
       },
@@ -97,7 +97,7 @@ async function process<Model extends ILlmSchema.Model>(
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  role: AutoBeAnalyzeRole;
+  actor: AutoBeAnalyzeActor;
   build: (next: IAutoBeInterfaceAuthorizationsApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
@@ -110,7 +110,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
     if (result.success === false) return result;
 
     // remove login operation for guest role
-    if (props.role.kind === "guest") {
+    if (props.actor.kind === "guest") {
       result.data.operations = result.data.operations.filter(
         (op) => op.authorizationType !== "login",
       );
@@ -118,9 +118,9 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
     const errors: IValidation.IError[] = [];
     result.data.operations.forEach((op, i) => {
-      // validate authorizationRole
-      if (op.authorizationRole !== null) {
-        op.authorizationRole = props.role.name;
+      // validate authorizationActor
+      if (op.authorizationActor !== null) {
+        op.authorizationActor = props.actor.name;
       }
 
       // validate responseBody.typeName -> must be ~.IAuthorized
@@ -150,7 +150,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
             For authentication operations (login, join, refresh), the response body type name must follow the convention "I{RoleName}.IAuthorized".
 
             This standardized naming convention ensures consistency across all authentication endpoints and clearly identifies authorization response types.
-            The Role name should be in PascalCase format (e.g., IUser.IAuthorized, IAdmin.IAuthorized, ISeller.IAuthorized).
+            The actor name should be in PascalCase format (e.g., IUser.IAuthorized, IAdmin.IAuthorized, ISeller.IAuthorized).
           `,
         });
     });
@@ -165,7 +165,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
         .filter((v) => v !== null),
     );
     for (const type of typia.misc.literals<AuthorizationType>())
-      if (props.role.kind === "guest" && type === "login") continue;
+      if (props.actor.kind === "guest" && type === "login") continue;
       else if (authorizationTypes.has(type) === false)
         errors.push({
           path: "$input.operations[].authorizationType",
@@ -176,10 +176,10 @@ function createController<Model extends ILlmSchema.Model>(props: {
           value: `No authorizationType "${type}" found in any operation`,
           description: StringUtil.trim`
           There must be an operation that has defined AutoBeOpenApi.IOperation.authorizationType := "${type}"
-          for the "${props.role}" role's authorization activity; "${type}".
+          for the "${props.actor}" role's authorization activity; "${type}".
 
           However, none of the operations have the AutoBeOpenApi.IOperation.authorizationType := "${type}"
-          value, so that the "${props.role}" cannot perform the authorization ${type} activity.
+          value, so that the "${props.actor}" cannot perform the authorization ${type} activity.
 
           Please make that operation at the next function calling. You have to do it.
         `,

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeInterfaceEndpointsEvent,
+  AutoBeInterfaceEndpointEvent,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
@@ -72,7 +72,7 @@ async function process<Model extends ILlmSchema.Model>(
     value: null,
   };
   const { tokenUsage } = await ctx.conversate({
-    source: "interfaceEndpoints",
+    source: "interfaceEndpoint",
     histories: transformInterfaceEndpointHistories({
       state: ctx.state(),
       group: props.group,
@@ -92,8 +92,8 @@ async function process<Model extends ILlmSchema.Model>(
   });
   if (pointer.value === null) throw new Error("Failed to generate endpoints."); // unreachable
 
-  const event: AutoBeInterfaceEndpointsEvent = {
-    type: "interfaceEndpoints",
+  const event: AutoBeInterfaceEndpointEvent = {
+    type: "interfaceEndpoint",
     id: v7(),
     endpoints: new HashSet(
       pointer.value,

package/src/orchestrate/interface/orchestrateInterfaceEndpointsReview.ts

@@ -23,7 +23,7 @@ export async function orchestrateInterfaceEndpointsReview<
     };
 
   const { tokenUsage } = await ctx.conversate({
-    source: "interfaceEndpointsReview",
+    source: "interfaceEndpointReview",
     histories: transformInterfaceEndpointsReviewHistories(
       ctx.state(),
       endpoints,
@@ -46,7 +46,7 @@ export async function orchestrateInterfaceEndpointsReview<
 
   ctx.dispatch({
     id: v7(),
-    type: "interfaceEndpointsReview",
+    type: "interfaceEndpointReview",
     endpoints,
     content: response,
     created_at: new Date().toISOString(),

package/src/orchestrate/interface/orchestrateInterfaceGroups.ts

@@ -1,5 +1,5 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeInterfaceGroupsEvent } from "@autobe/interface";
+import { AutoBeInterfaceGroupEvent } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -18,13 +18,13 @@ export async function orchestrateInterfaceGroups<
     instruction: string;
     message?: string;
   },
-): Promise<AutoBeInterfaceGroupsEvent> {
+): Promise<AutoBeInterfaceGroupEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBeInterfaceGroupApplication.IProps | null> = {
     value: null,
   };
   const { tokenUsage } = await ctx.conversate({
-    source: "interfaceGroups",
+    source: "interfaceGroup",
     histories: transformInterfaceGroupHistories({
       state: ctx.state(),
       instruction: props.instruction,
@@ -40,13 +40,13 @@ export async function orchestrateInterfaceGroups<
   });
   if (pointer.value === null) throw new Error("Failed to generate groups."); // unreachable
   return {
-    type: "interfaceGroups",
+    type: "interfaceGroup",
     id: v7(),
     created_at: start.toISOString(),
     groups: pointer.value.groups,
     tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
-  } satisfies AutoBeInterfaceGroupsEvent;
+  } satisfies AutoBeInterfaceGroupEvent;
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeInterfaceOperationsEvent,
+  AutoBeInterfaceOperationEvent,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
@@ -120,7 +120,7 @@ async function process<Model extends ILlmSchema.Model>(
     value: null,
   };
   const { tokenUsage } = await ctx.conversate({
-    source: "interfaceOperations",
+    source: "interfaceOperation",
     histories: transformInterfaceOperationHistories({
       state: ctx.state(),
       endpoints: props.endpoints.toJSON(),
@@ -128,11 +128,11 @@ async function process<Model extends ILlmSchema.Model>(
     }),
     controller: createController({
       model: ctx.model,
-      roles: ctx.state().analyze?.roles.map((it) => it.name) ?? [],
+      actors: ctx.state().analyze?.actors.map((it) => it.name) ?? [],
       build: (operations) => {
         pointer.value ??= [];
         const matrix: AutoBeOpenApi.IOperation[][] = operations.map((op) => {
-          if (op.authorizationRoles.length === 0)
+          if (op.authorizationActors.length === 0)
             return [
               {
                 ...op,
@@ -141,19 +141,19 @@ async function process<Model extends ILlmSchema.Model>(
                   [prefix, ...op.path.split("/")]
                     .filter((it) => it !== "")
                     .join("/"),
-                authorizationRole: null,
+                authorizationActor: null,
                 authorizationType: null,
                 prerequisites: [],
               },
             ];
-          return op.authorizationRoles.map((role) => ({
+          return op.authorizationActors.map((actor) => ({
             ...op,
             path:
               "/" +
-              [prefix, role, ...op.path.split("/")]
+              [prefix, actor, ...op.path.split("/")]
                 .filter((it) => it !== "")
                 .join("/"),
-            authorizationRole: role,
+            authorizationActor: actor,
             authorizationType: null,
             prerequisites: [],
           }));
@@ -163,10 +163,10 @@ async function process<Model extends ILlmSchema.Model>(
         props.progress.total += operations
           .map((op) =>
             props.endpoints.has({ path: op.path, method: op.method })
-              ? op.authorizationRoles.length === 0
+              ? op.authorizationActors.length === 0
                 ? 0
-                : op.authorizationRoles.length - 1
-              : op.authorizationRoles.length,
+                : op.authorizationActors.length - 1
+              : op.authorizationActors.length,
           )
           .reduce((a, b) => a + b, 0);
       },
@@ -178,20 +178,20 @@ async function process<Model extends ILlmSchema.Model>(
   if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
 
   ctx.dispatch({
-    type: "interfaceOperations",
+    type: "interfaceOperation",
     id: v7(),
     operations: pointer.value,
     tokenUsage,
     ...props.progress,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
-  } satisfies AutoBeInterfaceOperationsEvent);
+  } satisfies AutoBeInterfaceOperationEvent);
   return pointer.value;
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  roles: string[];
+  actors: string[];
   build: (
     operations: IAutoBeInterfaceOperationApplication.IOperation[],
   ) => void;
@@ -216,21 +216,21 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
     operations.forEach((op, i) => {
       // validate roles
-      if (props.roles.length === 0) op.authorizationRoles = [];
-      else if (op.authorizationRoles.length !== 0 && props.roles.length !== 0)
-        op.authorizationRoles.forEach((role, j) => {
-          if (props.roles.includes(role) === true) return;
+      if (props.actors.length === 0) op.authorizationActors = [];
+      else if (op.authorizationActors.length !== 0 && props.actors.length !== 0)
+        op.authorizationActors.forEach((actor, j) => {
+          if (props.actors.includes(actor) === true) return;
           errors.push({
-            path: `$input.operations[${i}].authorizationRoles[${j}]`,
-            expected: `null | ${props.roles.map((str) => JSON.stringify(str)).join(" | ")}`,
+            path: `$input.operations[${i}].authorizationActors[${j}]`,
+            expected: `null | ${props.actors.map((str) => JSON.stringify(str)).join(" | ")}`,
             description: StringUtil.trim`
-              Role "${role}" is not defined in the roles list.
+              Actor "${actor}" is not defined in the roles list.
 
               Please select one of them below, or do not define (\`null\`):  
 
-              ${props.roles.map((role) => `- ${role}`).join("\n")}
+              ${props.actors.map((role) => `- ${role}`).join("\n")}
             `,
-            value: role,
+            value: actor,
           });
         });
     });

package/src/orchestrate/interface/orchestrateInterfaceOperationsReview.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeInterfaceOperationsReviewEvent,
+  AutoBeInterfaceOperationReviewEvent,
   AutoBeOpenApi,
   AutoBePrisma,
   AutoBeProgressEventBase,
@@ -29,7 +29,7 @@ export async function orchestrateInterfaceOperationsReview<
         value: null,
       };
     const { tokenUsage } = await ctx.conversate({
-      source: "interfaceOperationsReview",
+      source: "interfaceOperationReview",
       histories: transformInterfaceOperationsReviewHistories(ctx, operations),
       controller: createReviewController({
         model: ctx.model,
@@ -54,7 +54,7 @@ export async function orchestrateInterfaceOperationsReview<
     );
 
     ctx.dispatch({
-      type: "interfaceOperationsReview",
+      type: "interfaceOperationReview",
       id: v7(),
       operations: content,
       review: pointer.value.think.review,
@@ -65,7 +65,7 @@ export async function orchestrateInterfaceOperationsReview<
       step: ctx.state().analyze?.step ?? 0,
       total: progress.total,
       completed: ++progress.completed,
-    } satisfies AutoBeInterfaceOperationsReviewEvent);
+    } satisfies AutoBeInterfaceOperationReviewEvent);
     return content;
   } catch {
     ++progress.completed;

package/src/orchestrate/interface/orchestrateInterfacePrerequisites.ts

@@ -108,7 +108,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 
   try {
     const { tokenUsage } = await ctx.conversate({
-      source: "interfacePrerequisites",
+      source: "interfacePrerequisite",
       controller: createController({
         model: ctx.model,
         document: props.document,
@@ -131,7 +131,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 
     props.progress.completed += pointer.value.length;
     ctx.dispatch({
-      type: "interfacePrerequisites",
+      type: "interfacePrerequisite",
       id: v7(),
       created_at: new Date().toISOString(),
       tokenUsage,

package/src/orchestrate/interface/orchestrateInterfaceSchemaRename.ts

@@ -0,0 +1,269 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeInterfaceSchemaRefactor,
+  AutoBeInterfaceSchemaRenameEvent,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
+import {
+  ILlmApplication,
+  ILlmSchema,
+  OpenApi,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeConfigConstant } from "../../constants/AutoBeConfigConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { divideArray } from "../../utils/divideArray";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { transformInterfaceSchemaRenameHistories } from "./histories/transformInterfaceSchemaRenameHistories";
+import { IAutoBeInterfaceSchemaRenameApplication } from "./structures/IAutoBeInterfaceSchemaRenameApplication";
+
+export async function orchestrateInterfaceSchemaRename<
+  Mode extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Mode>,
+  document: AutoBeOpenApi.IDocument,
+  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY * 10,
+): Promise<void> {
+  const tableNames: string[] = ctx
+    .state()
+    .prisma!.result.data.files.map((f) => f.models)
+    .flat()
+    .map((m) => m.name)
+    .filter((m) => m.startsWith("mv_") === false);
+  const entireTypeNames: Set<string> = new Set();
+  for (let name of Object.keys(document.components.schemas)) {
+    if (name.startsWith("IPage")) name = name.replace("IPage", "");
+    name = name.split(".")[0];
+    entireTypeNames.add(name);
+  }
+
+  const matrix: string[][] = divideArray({
+    array: Array.from(entireTypeNames),
+    capacity,
+  });
+  const progress: AutoBeProgressEventBase = {
+    total: entireTypeNames.size,
+    completed: 0,
+  };
+  const refactors: AutoBeInterfaceSchemaRefactor[] = uniqueRefactors(
+    (
+      await executeCachedBatch(
+        matrix.map(
+          (typeNames) => (promptCacheKey) =>
+            divideAndConquer(ctx, {
+              tableNames,
+              typeNames,
+              promptCacheKey,
+              progress,
+            }),
+        ),
+      )
+    ).flat(),
+  );
+  orchestrateInterfaceSchemaRename.rename(document, refactors);
+}
+export namespace orchestrateInterfaceSchemaRename {
+  export const rename = (
+    document: AutoBeOpenApi.IDocument,
+    refactors: AutoBeInterfaceSchemaRefactor[],
+  ): void => {
+    // REPLACE RULE
+    const replace = (typeName: string): string | null => {
+      // exact match
+      const exact: AutoBeInterfaceSchemaRefactor | undefined = refactors.find(
+        (r) => r.from === typeName,
+      );
+      if (exact !== undefined) return exact.to;
+
+      // T.X match
+      const prefix: AutoBeInterfaceSchemaRefactor | undefined = refactors.find(
+        (r) => typeName.startsWith(`${r.from}.`),
+      );
+      if (prefix !== undefined)
+        return typeName.replace(`${prefix.from}.`, `${prefix.to}.`);
+
+      // IPageT exact match
+      const pageExact: AutoBeInterfaceSchemaRefactor | undefined =
+        refactors.find((r) => typeName === `IPage${r.from}`);
+      if (pageExact !== undefined) return `IPage${pageExact.to}`;
+
+      // IPageT.X match
+      const pagePrefix: AutoBeInterfaceSchemaRefactor | undefined =
+        refactors.find((r) => typeName.startsWith(`IPage${r.from}.`));
+      if (pagePrefix !== undefined)
+        return typeName.replace(
+          `IPage${pagePrefix.from}.`,
+          `IPage${pagePrefix.to}.`,
+        );
+      return null;
+    };
+
+    // JSON SCHEMA REFERENCES
+    const $refChangers: Map<OpenApi.IJsonSchema, () => void> = new Map();
+    for (const value of Object.values(document.components.schemas))
+      OpenApiTypeChecker.visit({
+        components: document.components,
+        schema: value,
+        closure: (schema) => {
+          if (OpenApiTypeChecker.isReference(schema) === false) return;
+          const x: string = schema.$ref.split("/").pop()!;
+          const y: string | null = replace(x);
+          if (y !== null)
+            $refChangers.set(schema, () => {
+              schema.$ref = `#/components/schemas/${y}`;
+            });
+        },
+      });
+    for (const fn of $refChangers.values()) fn();
+
+    // COMPONENT SCHEMAS
+    for (const x of Object.keys(document.components.schemas)) {
+      const y: string | null = replace(x);
+      if (y !== null) {
+        document.components.schemas[y] = document.components.schemas[x];
+        delete document.components.schemas[x];
+      }
+    }
+
+    // OPERATIONS
+    for (const op of document.operations) {
+      if (op.requestBody)
+        op.requestBody.typeName =
+          replace(op.requestBody.typeName) ?? op.requestBody.typeName;
+      if (op.responseBody)
+        op.responseBody.typeName =
+          replace(op.responseBody.typeName) ?? op.responseBody.typeName;
+    }
+  };
+}
+
+const divideAndConquer = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    tableNames: string[];
+    typeNames: string[];
+    promptCacheKey: string;
+    progress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeInterfaceSchemaRefactor[]> => {
+  try {
+    const pointer: IPointer<IAutoBeInterfaceSchemaRenameApplication.IProps | null> =
+      {
+        value: null,
+      };
+    const { tokenUsage } = await ctx.conversate({
+      source: "interfaceSchemaRename",
+      controller: createController<Model>(
+        ctx.model,
+        (value) => (pointer.value = value),
+      ),
+      histories: transformInterfaceSchemaRenameHistories(props),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      message: "Rename DTO type names for consistency and clarity.",
+    });
+    if (pointer.value === null) {
+      props.progress.completed += props.typeNames.length;
+      return [];
+    }
+
+    pointer.value.refactors = uniqueRefactors(pointer.value.refactors);
+    ctx.dispatch({
+      type: "interfaceSchemaRename",
+      id: v7(),
+      refactors: pointer.value.refactors,
+      total: props.progress.total,
+      completed: (props.progress.completed += props.typeNames.length),
+      tokenUsage,
+      created_at: new Date().toISOString(),
+    } satisfies AutoBeInterfaceSchemaRenameEvent);
+    return pointer.value.refactors;
+  } catch {
+    props.progress.completed += props.typeNames.length;
+    return [];
+  }
+};
+
+const uniqueRefactors = (
+  refactors: AutoBeInterfaceSchemaRefactor[],
+): AutoBeInterfaceSchemaRefactor[] => {
+  // Remove self-references (A->A)
+  refactors = refactors.filter((r) => r.from !== r.to);
+
+  // Remove duplicates (keep the first occurrence)
+  refactors = Array.from(new Map(refactors.map((r) => [r.from, r])).values());
+
+  // Build adjacency map: from -> to
+  const renameMap: Map<string, string> = new Map();
+  for (const r of refactors) {
+    renameMap.set(r.from, r.to);
+  }
+
+  // Resolve transitive chains: A->B, B->C becomes A->C
+  const resolveChain = (from: string): string => {
+    const visited: Set<string> = new Set();
+    let current: string = from;
+
+    while (renameMap.has(current)) {
+      // Cycle detection: A->B, B->C, C->A
+      if (visited.has(current)) {
+        // Cycle detected, keep the last valid mapping before cycle
+        return current;
+      }
+      visited.add(current);
+      current = renameMap.get(current)!;
+    }
+    return current;
+  };
+
+  // Build final refactor list with resolved chains
+  const resolved: Map<string, AutoBeInterfaceSchemaRefactor> = new Map();
+  for (const from of renameMap.keys()) {
+    const finalTo: string = resolveChain(from);
+    // Only include if actually changes
+    if (from !== finalTo) {
+      resolved.set(from, {
+        from,
+        to: finalTo,
+      });
+    }
+  }
+  return Array.from(resolved.values());
+};
+
+const createController = <Model extends ILlmSchema.Model>(
+  model: Model,
+  build: (value: IAutoBeInterfaceSchemaRenameApplication.IProps) => void,
+): IAgenticaController.IClass<Model> => {
+  assertSchemaModel(model);
+  const application: ILlmApplication<Model> = collection[
+    model === "chatgpt" ? "chatgpt" : "claude"
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "SchemaRenamer",
+    application,
+    execute: {
+      rename: (props) => {
+        build(props);
+      },
+    } satisfies IAutoBeInterfaceSchemaRenameApplication,
+  };
+};
+
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeInterfaceSchemaRenameApplication,
+    "chatgpt"
+  >(),
+  claude: typia.llm.application<
+    IAutoBeInterfaceSchemaRenameApplication,
+    "claude"
+  >(),
+};