@autobe/agent 0.28.1 → 0.29.0

package/src/orchestrate/interface/{orchestrateInterfacePrerequisites.ts → orchestrateInterfacePrerequisite.ts}

@@ -1,5 +1,9 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeOpenApi, AutoBeProgressEventBase } from "@autobe/interface";
+import {
+  AutoBeEventSource,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
 import { AutoBeInterfacePrerequisite } from "@autobe/interface/src/histories/contents/AutoBeInterfacePrerequisite";
 import { AutoBeOpenApiEndpointComparator } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
@@ -12,15 +16,15 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformInterfacePrerequisitesHistories } from "./histories/transformInterfacePrerequisitesHistories";
-import { IAutoBeInterfacePrerequisitesApplication } from "./structures/IAutoBeInterfacePrerequisitesApplication";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformInterfacePrerequisiteHistory } from "./histories/transformInterfacePrerequisiteHistory";
+import { IAutoBeInterfacePrerequisiteApplication } from "./structures/IAutoBeInterfacePrerequisiteApplication";
 
-export async function orchestrateInterfacePrerequisites<
+export async function orchestrateInterfacePrerequisite<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
   document: AutoBeOpenApi.IDocument,
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
 ): Promise<AutoBeInterfacePrerequisite[]> {
   const operations: AutoBeOpenApi.IOperation[] =
     document.operations.filter((op) => op.authorizationType === null) ?? [];
@@ -59,10 +63,10 @@ export async function orchestrateInterfacePrerequisites<
   do {
     const matrix: AutoBeOpenApi.IOperation[][] = divideArray({
       array: include,
-      capacity: capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
+      capacity: AutoBeConfigConstant.INTERFACE_CAPACITY,
     });
-
     await executeCachedBatch(
+      ctx,
       matrix.map((ops) => async (promptCacheKey) => {
         const row: AutoBeInterfacePrerequisite[] = await divideAndConquer(ctx, {
           dict: dict,
@@ -102,50 +106,91 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
     prerequisitesNotFound: string;
   },
 ): Promise<AutoBeInterfacePrerequisite[]> {
-  const pointer: IPointer<AutoBeInterfacePrerequisite[] | null> = {
-    value: null,
-  };
-
   try {
-    const { metric, tokenUsage } = await ctx.conversate({
-      source: "interfacePrerequisite",
+    return await process(ctx, props);
+  } catch {
+    props.progress.completed += props.includes.length;
+    return [];
+  }
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
+    document: AutoBeOpenApi.IDocument;
+    includes: AutoBeOpenApi.IOperation[];
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    prerequisitesNotFound: string;
+  },
+): Promise<AutoBeInterfacePrerequisite[]> {
+  const preliminary: AutoBePreliminaryController<
+    | "analysisFiles"
+    | "prismaSchemas"
+    | "interfaceOperations"
+    | "interfaceSchemas"
+  > = new AutoBePreliminaryController({
+    application:
+      typia.json.application<IAutoBeInterfacePrerequisiteApplication>(),
+    source: SOURCE,
+    kinds: [
+      "analysisFiles",
+      "prismaSchemas",
+      "interfaceOperations",
+      "interfaceSchemas",
+    ],
+    state: ctx.state(),
+    all: {
+      interfaceOperations: props.document.operations,
+      interfaceSchemas: props.document.components.schemas,
+    },
+    local: {
+      interfaceOperations: props.includes,
+    },
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<AutoBeInterfacePrerequisite[] | null> = {
+      value: null,
+    };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
       controller: createController({
         model: ctx.model,
         document: props.document,
         dict: props.dict,
         includes: props.includes,
         prerequisitesNotFound: props.prerequisitesNotFound,
+        preliminary,
         build: (next) => {
           pointer.value = next;
         },
       }),
-      histories: transformInterfacePrerequisitesHistories(
-        props.document,
-        props.includes,
-      ),
       enforceFunctionCall: true,
       promptCacheKey: props.promptCacheKey,
-      message: "Create prerequisite for the given operations",
-    });
-    if (pointer.value === null) return [];
-
-    props.progress.completed += pointer.value.length;
-    ctx.dispatch({
-      type: "interfacePrerequisite",
-      id: v7(),
-      created_at: new Date().toISOString(),
-      metric,
-      tokenUsage,
-      operations: pointer.value,
-      total: props.progress.total,
-      completed: props.progress.completed,
-      step: ctx.state().prisma?.step ?? 0,
+      ...transformInterfacePrerequisiteHistory({
+        document: props.document,
+        includes: props.includes,
+        preliminary,
+      }),
     });
-    return pointer.value;
-  } catch {
-    props.progress.completed += props.includes.length;
-    return [];
-  }
+    if (pointer.value !== null) {
+      props.progress.completed += pointer.value.length;
+      ctx.dispatch({
+        type: SOURCE,
+        id: v7(),
+        created_at: new Date().toISOString(),
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        operations: pointer.value,
+        total: props.progress.total,
+        completed: props.progress.completed,
+        step: ctx.state().prisma?.step ?? 0,
+      });
+      return out(result)(pointer.value);
+    }
+    return out(result)(null);
+  });
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
@@ -154,18 +199,30 @@ function createController<Model extends ILlmSchema.Model>(props: {
   dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
   includes: AutoBeOpenApi.IOperation[];
   prerequisitesNotFound: string;
+  preliminary: AutoBePreliminaryController<
+    | "analysisFiles"
+    | "prismaSchemas"
+    | "interfaceOperations"
+    | "interfaceSchemas"
+  >;
   build: (next: AutoBeInterfacePrerequisite[]) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
   const validate = (
     next: unknown,
-  ): IValidation<IAutoBeInterfacePrerequisitesApplication.IProps> => {
-    const result: IValidation<IAutoBeInterfacePrerequisitesApplication.IProps> =
-      typia.validate<IAutoBeInterfacePrerequisitesApplication.IProps>(next);
+  ): IValidation<IAutoBeInterfacePrerequisiteApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfacePrerequisiteApplication.IProps> =
+      typia.validate<IAutoBeInterfacePrerequisiteApplication.IProps>(next);
     if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
 
-    const operations: AutoBeInterfacePrerequisite[] = result.data.operations;
+    const operations: AutoBeInterfacePrerequisite[] =
+      result.data.request.operations;
     const filteredOperations: AutoBeInterfacePrerequisite[] = [];
     const errors: IValidation.IError[] = [];
 
@@ -199,7 +256,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
         if (props.dict.has(p.endpoint) === false) {
           errors.push({
             value: p.endpoint,
-            path: `$input.operations[${i}].prerequisites[${j}].endpoint`,
+            path: `$input.request.operations[${i}].prerequisites[${j}].endpoint`,
             expected: "AutoBeOpenApi.IEndpoint",
             description: props.prerequisitesNotFound,
           });
@@ -211,7 +268,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
         ) {
           errors.push({
             value: p.endpoint,
-            path: `$input.operations[${i}].prerequisites[${j}].endpoint`,
+            path: `$input.request.operations[${i}].prerequisites[${j}].endpoint`,
             expected: "AutoBeOpenApi.IEndpoint",
             description: "Self-reference is not allowed.",
           });
@@ -221,17 +278,23 @@ function createController<Model extends ILlmSchema.Model>(props: {
 
     return errors.length === 0
       ? {
-          ...result,
+          success: true,
           data: {
             ...result.data,
-            operations: filteredOperations,
+            request: {
+              ...result.data.request,
+              operations: filteredOperations,
+            },
           },
         }
       : {
           success: false,
           data: {
             ...result.data,
-            operations: filteredOperations,
+            request: {
+              ...result.data.request,
+              operations: filteredOperations,
+            },
           },
           errors,
         };
@@ -246,40 +309,42 @@ function createController<Model extends ILlmSchema.Model>(props: {
   ](
     validate,
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
-
   return {
     protocol: "class",
-    name: "interface",
+    name: SOURCE,
     application,
     execute: {
-      makePrerequisite: (next) => {
-        props.build(next.operations);
+      process: (next) => {
+        if (next.request.type === "complete")
+          props.build(next.request.operations);
       },
-    } satisfies IAutoBeInterfacePrerequisitesApplication,
+    } satisfies IAutoBeInterfacePrerequisiteApplication,
   };
 }
 
 const collection = {
   chatgpt: (validate: Validator) =>
-    typia.llm.application<IAutoBeInterfacePrerequisitesApplication, "chatgpt">({
+    typia.llm.application<IAutoBeInterfacePrerequisiteApplication, "chatgpt">({
       validate: {
-        makePrerequisite: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
-    typia.llm.application<IAutoBeInterfacePrerequisitesApplication, "claude">({
+    typia.llm.application<IAutoBeInterfacePrerequisiteApplication, "claude">({
       validate: {
-        makePrerequisite: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
-    typia.llm.application<IAutoBeInterfacePrerequisitesApplication, "gemini">({
+    typia.llm.application<IAutoBeInterfacePrerequisiteApplication, "gemini">({
       validate: {
-        makePrerequisite: validate,
+        process: validate,
       },
     }),
 };
 
 type Validator = (
   input: unknown,
-) => IValidation<IAutoBeInterfacePrerequisitesApplication.IProps>;
+) => IValidation<IAutoBeInterfacePrerequisiteApplication.IProps>;
+
+const SOURCE = "interfacePrerequisite" satisfies AutoBeEventSource;

package/src/orchestrate/interface/{orchestrateInterfaceSchemas.ts → orchestrateInterfaceSchema.ts}

@@ -1,10 +1,10 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeEventSource,
   AutoBeInterfaceSchemaEvent,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
@@ -16,21 +16,21 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformInterfaceSchemaHistories } from "./histories/transformInterfaceSchemaHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformInterfaceSchemaHistory } from "./histories/transformInterfaceSchemaHistory";
 import { IAutoBeInterfaceSchemaApplication } from "./structures/IAutoBeInterfaceSchemaApplication";
 import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
 import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
 import { JsonSchemaValidator } from "./utils/JsonSchemaValidator";
 import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
 
-export async function orchestrateInterfaceSchemas<
+export async function orchestrateInterfaceSchema<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
   props: {
     operations: AutoBeOpenApi.IOperation[];
     instruction: string;
-    capacity?: number;
   },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   // fix operation type names
@@ -48,7 +48,7 @@ export async function orchestrateInterfaceSchemas<
   // divide and conquer
   const matrix: string[][] = divideArray({
     array: Array.from(typeNames),
-    capacity: props.capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
+    capacity: AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
   const progress: AutoBeProgressEventBase = {
     total: typeNames.size,
@@ -58,6 +58,7 @@ export async function orchestrateInterfaceSchemas<
     ...presets,
   };
   for (const y of await executeCachedBatch(
+    ctx,
     matrix.map((it) => async (promptCacheKey) => {
       const operations: AutoBeOpenApi.IOperation[] = props.operations.filter(
         (op) =>
@@ -74,13 +75,8 @@ export async function orchestrateInterfaceSchemas<
         });
       return row;
     }),
-  )) {
-    JsonSchemaNamingConvention.schemas(props.operations, x, y);
+  ))
     Object.assign(x, y);
-  }
-  Object.assign(x, presets);
-  JsonSchemaNamingConvention.schemas(props.operations, x);
-  JsonSchemaFactory.authorize(x);
   return x;
 }
 
@@ -127,76 +123,68 @@ async function process<Model extends ILlmSchema.Model>(
   },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const already: string[] = Object.keys(props.oldbie);
-  const pointer: IPointer<Record<
-    string,
-    AutoBeOpenApi.IJsonSchemaDescriptive
-  > | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "interfaceSchema",
-    histories: transformInterfaceSchemaHistories({
-      state: ctx.state(),
-      typeNames: Array.from(
-        new Set([...props.remained, ...Object.keys(props.oldbie)]),
-      ),
-      operations: props.operations,
-      instruction: props.instruction,
-    }),
-    controller: createController({
-      model: ctx.model,
-      build: async (next) => {
-        pointer.value ??= {};
-        Object.assign(pointer.value, next);
-      },
-      pointer,
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: StringUtil.trim`
-      Make type components please.
-
-      Here is the list of request/response bodies' type names from
-      OpenAPI operations. Make type components of them. If more object
-      types are required during making the components, please make them
-      too.
-
-      ${Array.from(props.remained)
-        .map((k) => `- \`${k}\``)
-        .join("\n")}${
-        already.length !== 0
-          ? StringUtil.trim`
-
-            > By the way, here is the list of components schemas what you've
-            > already made. So, you don't need to make them again.
-            >
-            ${already.map((k) => `> - \`${k}\``).join("\n")}
-          `
-          : ""
-      }
-    `,
+  const preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas" | "interfaceOperations"
+  > = new AutoBePreliminaryController({
+    application: typia.json.application<IAutoBeInterfaceSchemaApplication>(),
+    source: SOURCE,
+    kinds: ["analysisFiles", "prismaSchemas", "interfaceOperations"],
+    state: ctx.state(),
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<Record<
+      string,
+      AutoBeOpenApi.IJsonSchemaDescriptive
+    > | null> = {
+      value: null,
+    };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createController({
+        model: ctx.model,
+        build: async (next) => {
+          pointer.value ??= {};
+          Object.assign(pointer.value, next);
+        },
+        pointer,
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformInterfaceSchemaHistory({
+        preliminary,
+        typeNames: Array.from(
+          new Set([...props.remained, ...Object.keys(props.oldbie)]),
+        ),
+        operations: props.operations,
+        instruction: props.instruction,
+        remained: props.remained,
+        already,
+      }),
+    });
+    if (pointer.value !== null) {
+      const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = ((
+        OpenApiV3_1Emender.convertComponents({
+          schemas: pointer.value,
+        }) as AutoBeOpenApi.IComponents
+      ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+      ctx.dispatch({
+        type: SOURCE,
+        id: v7(),
+        schemas,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        completed: (props.progress.completed += Object.keys(schemas).length),
+        total: (props.progress.total += Object.keys(schemas).filter(
+          (k) => props.remained.has(k) === false,
+        ).length),
+        step: ctx.state().prisma?.step ?? 0,
+        created_at: new Date().toISOString(),
+      } satisfies AutoBeInterfaceSchemaEvent);
+      return out(result)(schemas);
+    }
+    return out(result)(null);
   });
-  if (pointer.value === null) throw new Error("Failed to create components.");
-
-  const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = ((
-    OpenApiV3_1Emender.convertComponents({
-      schemas: pointer.value,
-    }) as AutoBeOpenApi.IComponents
-  ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
-  ctx.dispatch({
-    type: "interfaceSchema",
-    id: v7(),
-    schemas,
-    metric,
-    tokenUsage,
-    completed: (props.progress.completed += Object.keys(schemas).length),
-    total: (props.progress.total += Object.keys(schemas).filter(
-      (k) => props.remained.has(k) === false,
-    ).length),
-    step: ctx.state().prisma?.step ?? 0,
-    created_at: new Date().toISOString(),
-  } satisfies AutoBeInterfaceSchemaEvent);
-  return schemas;
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
@@ -208,27 +196,42 @@ function createController<Model extends ILlmSchema.Model>(props: {
     string,
     AutoBeOpenApi.IJsonSchemaDescriptive
   > | null>;
+  preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas" | "interfaceOperations"
+  >;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
   const validate = (
     next: unknown,
   ): IValidation<IAutoBeInterfaceSchemaApplication.IProps> => {
-    JsonSchemaFactory.fixPage("schemas", next);
+    if (
+      typia.is<{
+        request: {
+          type: "complete";
+          schemas: object;
+        };
+      }>(next)
+    )
+      JsonSchemaFactory.fixPage("schemas", next.request);
 
     const result: IValidation<IAutoBeInterfaceSchemaApplication.IProps> =
       typia.validate<IAutoBeInterfaceSchemaApplication.IProps>(next);
     if (result.success === false) {
       fulfillJsonSchemaErrorMessages(result.errors);
       return result;
-    }
+    } else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
 
     // Check all IAuthorized types
     const errors: IValidation.IError[] = [];
     JsonSchemaValidator.validateSchemas({
       errors,
-      schemas: result.data.schemas,
-      path: "$input.schemas",
+      schemas: result.data.request.schemas,
+      path: "$input.request.schemas",
     });
     if (errors.length !== 0)
       return {
@@ -250,11 +253,12 @@ function createController<Model extends ILlmSchema.Model>(props: {
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "interface",
+    name: SOURCE,
     application,
     execute: {
-      makeComponents: async (next) => {
-        await props.build(next.schemas);
+      process: async (next) => {
+        if (next.request.type === "complete")
+          await props.build(next.request.schemas);
       },
     } satisfies IAutoBeInterfaceSchemaApplication,
   };
@@ -264,19 +268,19 @@ const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeInterfaceSchemaApplication, "chatgpt">({
       validate: {
-        makeComponents: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
     typia.llm.application<IAutoBeInterfaceSchemaApplication, "claude">({
       validate: {
-        makeComponents: validate,
+        process: validate,
       },
     }),
   gemini: (validate: Validator) =>
     typia.llm.application<IAutoBeInterfaceSchemaApplication, "gemini">({
       validate: {
-        makeComponents: validate,
+        process: validate,
       },
     }),
 };
@@ -284,3 +288,5 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceSchemaApplication.IProps>;
+
+const SOURCE = "interfaceSchema" satisfies AutoBeEventSource;

package/src/orchestrate/interface/orchestrateInterfaceSchemaRename.ts

@@ -1,5 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeEventSource,
   AutoBeInterfaceSchemaRefactor,
   AutoBeInterfaceSchemaRenameEvent,
   AutoBeOpenApi,
@@ -20,7 +21,7 @@ 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 { transformInterfaceSchemaRenameHistory } from "./histories/transformInterfaceSchemaRenameHistory";
 import { IAutoBeInterfaceSchemaRenameApplication } from "./structures/IAutoBeInterfaceSchemaRenameApplication";
 
 export async function orchestrateInterfaceSchemaRename<
@@ -54,6 +55,7 @@ export async function orchestrateInterfaceSchemaRename<
   const refactors: AutoBeInterfaceSchemaRefactor[] = uniqueRefactors(
     (
       await executeCachedBatch(
+        ctx,
         matrix.map(
           (typeNames) => (promptCacheKey) =>
             divideAndConquer(ctx, {
@@ -158,15 +160,14 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
         value: null,
       };
     const { metric, tokenUsage } = await ctx.conversate({
-      source: "interfaceSchemaRename",
+      source: SOURCE,
       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.",
+      ...transformInterfaceSchemaRenameHistory(props),
     });
     if (pointer.value === null) {
       props.progress.completed += props.typeNames.length;
@@ -175,7 +176,7 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
 
     pointer.value.refactors = uniqueRefactors(pointer.value.refactors);
     ctx.dispatch({
-      type: "interfaceSchemaRename",
+      type: SOURCE,
       id: v7(),
       refactors: pointer.value.refactors,
       total: props.progress.total,
@@ -244,15 +245,11 @@ const createController = <Model extends ILlmSchema.Model>(
 ): IAgenticaController.IClass<Model> => {
   assertSchemaModel(model);
   const application: ILlmApplication<Model> = collection[
-    model === "chatgpt"
-      ? "chatgpt"
-      : model === "gemini"
-        ? "gemini"
-        : "claude"
+    model === "chatgpt" ? "chatgpt" : model === "gemini" ? "gemini" : "claude"
   ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "SchemaRenamer",
+    name: SOURCE,
     application,
     execute: {
       rename: (props) => {
@@ -276,3 +273,5 @@ const collection = {
     "gemini"
   >(),
 };
+
+const SOURCE = "interfaceSchemaRename" satisfies AutoBeEventSource;