@autobe/agent 0.17.1 → 0.18.0

package/src/orchestrate/interface/histories/transformInterfaceOperationHistories.ts

@@ -1,5 +1,5 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeAnalyzeHistory, AutoBeOpenApi } from "@autobe/interface";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
@@ -11,24 +11,47 @@ export const transformInterfaceOperationHistories = (
   endpoints: AutoBeOpenApi.IEndpoint[],
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => [
-  {
-    type: "systemMessage",
-    id: v4(),
-    created_at: new Date().toISOString(),
-    text: AutoBeSystemPromptConstant.INTERFACE_OPERATION,
-  },
-  ...transformInterfaceAssetHistories(state),
-  {
-    type: "assistantMessage",
-    id: v4(),
-    created_at: new Date().toISOString(),
-    text: [
-      "You have to make API operations for the given endpoints:",
-      "",
-      "```json",
-      JSON.stringify(endpoints),
-      "```",
-    ].join("\n"),
-  },
-];
+> => {
+  const analyze: AutoBeAnalyzeHistory = state.analyze!;
+  return [
+    {
+      type: "systemMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_OPERATION,
+    },
+    ...transformInterfaceAssetHistories(state),
+    {
+      type: "systemMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: [
+        `## Service Prefix`,
+        `- Original: ${analyze.prefix}`,
+        `- PascalCase for DTOs: ${analyze.prefix
+          .split(/[-_]/)
+          .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+          .join("")}`,
+        `- Expected DTO pattern: I${analyze.prefix
+          .split(/[-_]/)
+          .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+          .join("")}{EntityName}`,
+      ].join("\n"),
+    },
+    {
+      type: "assistantMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: [
+        "You have to make API operations for the given endpoints:",
+        "",
+        "```json",
+        JSON.stringify(endpoints),
+        "```",
+        "",
+        "If there is a content in the failure, it is to explain why it failed before.",
+        "Please supplement or modify the Operation accordingly.",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/interface/histories/transformInterfaceOperationsReviewHistories.ts

@@ -0,0 +1,43 @@
+import { IMicroAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
+
+export function transformInterfaceOperationsReviewHistories<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+): Array<IMicroAgenticaHistoryJson> {
+  return [
+    {
+      type: "systemMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_OPERATION,
+    },
+    ...transformInterfaceAssetHistories(ctx.state()),
+    {
+      type: "systemMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_OPERATION_REVIEW,
+    },
+    {
+      type: "assistantMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: [
+        "Review the following API operations:",
+        "",
+        "```json",
+        JSON.stringify(operations, null, 2),
+        "```",
+      ].join("\n"),
+    },
+  ];
+}

package/src/orchestrate/interface/histories/transformInterfaceSchemasReviewHistories.ts

@@ -0,0 +1,63 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
+
+export const transformInterfaceSchemasReviewHistories = (
+  state: AutoBeState,
+  operations: AutoBeOpenApi.IOperation[],
+  schemaDescriptive: Record<
+    string,
+    AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
+  >,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      type: "systemMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_REVIEW,
+    },
+    ...transformInterfaceAssetHistories(state),
+    {
+      type: "assistantMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: [
+        "The Schema Agent has generated schemas for the following API operations.",
+        "These operations define what endpoints exist and what request/response types they use:",
+        "",
+        "```json",
+        JSON.stringify(operations, null, 2),
+        "```",
+        "",
+        "All schema types referenced in these operations (in requestBody and responses) must exist in the schemas.",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      type: "assistantMessage",
+      created_at: new Date().toISOString(),
+      text: [
+        "Here are the schemas generated by the Schema Agent that need your review:",
+        "",
+        "```json",
+        JSON.stringify(schemaDescriptive, null, 2),
+        "```",
+        "",
+        "Please review these schemas for:",
+        "1. Security vulnerabilities (passwords in responses, actor IDs in requests)",
+        "2. Missing entities or variants referenced by the operations",
+        "3. Type accuracy and format specifications",
+        "4. Alignment with Prisma schema and business requirements",
+        "",
+        "Fix all critical issues and return the enhanced schemas in the content field.",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -9,6 +9,7 @@ import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { orchestrateInterfaceAuthorizations } from "./orchestrateInterfaceAuthorizations";
 import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement";
 import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
 import { orchestrateInterfaceGroups } from "./orchestrateInterfaceGroups";
@@ -34,12 +35,18 @@ export const orchestrateInterface =
     if (init.type === "assistantMessage") return ctx.assistantMessage(init);
     else ctx.dispatch(init);
 
+    // AUTHORIZATION
+    const authorizations: AutoBeOpenApi.IOperation[] =
+      await orchestrateInterfaceAuthorizations(ctx);
+
     // ENDPOINTS & OPERATIONS
     const endpoints: AutoBeOpenApi.IEndpoint[] =
-      await orchestrateInterfaceEndpoints(ctx, init.groups);
+      await orchestrateInterfaceEndpoints(ctx, init.groups, authorizations);
     const operations: AutoBeOpenApi.IOperation[] =
       await orchestrateInterfaceOperations(ctx, endpoints);
 
+    operations.push(...authorizations);
+
     // TYPE SCHEMAS
     const document: AutoBeOpenApi.IDocument = {
       operations,
@@ -57,7 +64,8 @@ export const orchestrateInterface =
     return ctx.dispatch({
       type: "interfaceComplete",
       document,
-      created_at: start.toISOString(),
+      created_at: new Date().toISOString(),
+      elapsed: new Date().getTime() - start.getTime(),
       step: ctx.state().analyze?.step ?? 0,
     } satisfies AutoBeInterfaceCompleteEvent);
   };

package/src/orchestrate/interface/orchestrateInterfaceAuthorizations.ts

@@ -0,0 +1,106 @@
+import { IAgenticaController } from "@agentica/core";
+import { AutoBeAnalyzeRole, AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeInterfaceAuthorizationEvent } from "@autobe/interface/src/events/AutoBeInterfaceAuthorizationEvent";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { IProgress } from "../internal/IProgress";
+import { transformInterfaceAuthorizationsHistories } from "./histories/transformInterfaceAuthorizationsHistories";
+import { IAutoBeInterfaceAuthorizationsApplication } from "./structures/IAutoBeInterfaceAuthorizationsApplication";
+
+export async function orchestrateInterfaceAuthorizations<
+  Model extends ILlmSchema.Model,
+>(ctx: AutoBeContext<Model>): Promise<AutoBeOpenApi.IOperation[]> {
+  const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
+  const progress: IProgress = {
+    total: roles.length,
+    completed: 0,
+  };
+  const operations: AutoBeOpenApi.IOperation[][] = await Promise.all(
+    roles.map(async (role) => {
+      const event: AutoBeInterfaceAuthorizationEvent = await process(
+        ctx,
+        role,
+        progress,
+      );
+      ctx.dispatch(event);
+      return event.operations;
+    }),
+  );
+  return operations.flat();
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  role: AutoBeAnalyzeRole,
+  progress: IProgress,
+): Promise<AutoBeInterfaceAuthorizationEvent> {
+  const pointer: IPointer<IAutoBeInterfaceAuthorizationsApplication.IProps | null> =
+    {
+      value: null,
+    };
+  const { tokenUsage } = await ctx.conversate({
+    source: "interfaceAuthorization",
+    histories: transformInterfaceAuthorizationsHistories(ctx.state(), role),
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Create Authorization Operation for the given roles",
+  });
+  if (pointer.value === null)
+    throw new Error("Failed to generate authorization operation.");
+
+  return {
+    type: "interfaceAuthorization",
+    operations: pointer.value.operations,
+    completed: ++progress.completed,
+    tokenUsage,
+    created_at: new Date().toISOString(),
+    step: ctx.state().analyze?.step ?? 0,
+    total: progress.total,
+  } satisfies AutoBeInterfaceAuthorizationEvent;
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IAutoBeInterfaceAuthorizationsApplication.IProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: "Create Authorization Interface",
+    application,
+    execute: {
+      makeOperations: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeInterfaceAuthorizationsApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeInterfaceAuthorizationsApplication,
+  "claude"
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeInterfaceAuthorizationsApplication,
+    "chatgpt"
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -1,4 +1,4 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { IAgenticaController } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
 import {
   ILlmApplication,
@@ -11,8 +11,6 @@ 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 { transformInterfaceComplementHistories } from "./histories/transformInterfaceComplementHistories";
 import { IAutoBeInterfaceComplementApplication } from "./structures/IAutoBeInterfaceComplementApplication";
 
@@ -21,7 +19,7 @@ export function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(
   document: AutoBeOpenApi.IDocument,
   life: number = 8,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  return forceRetry(() => step(ctx, document, life));
+  return step(ctx, document, life);
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -40,54 +38,41 @@ async function step<Model extends ILlmSchema.Model>(
   > | null> = {
     value: null,
   };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-    },
+  const { tokenUsage } = await ctx.conversate({
+    source: "interfaceComplement",
     histories: transformInterfaceComplementHistories(
       ctx.state(),
       document,
       missed,
     ),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value ??= {};
-          Object.assign(
-            pointer.value,
-            (OpenApiV3_1Emender.convertComponents({
-              schemas: next,
-            }).schemas ?? {}) as Record<
-              string,
-              AutoBeOpenApi.IJsonSchemaDescriptive
-            >,
-          );
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  await agentica.conversate("Fill missing schema types please").finally(() => {
-    const tokenUsage = agentica.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["interface"]);
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value ??= {};
+        Object.assign(
+          pointer.value,
+          (OpenApiV3_1Emender.convertComponents({
+            schemas: next,
+          }).schemas ?? {}) as Record<
+            string,
+            AutoBeOpenApi.IJsonSchemaDescriptive
+          >,
+        );
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Fill missing schema types please",
   });
-  if (pointer.value === null) {
+  if (pointer.value === null)
     // unreachable
     throw new Error(
       "Failed to fill missing schema types. No response from agentica.",
     );
-  }
   ctx.dispatch({
     type: "interfaceComplement",
     missed,
     schemas: pointer.value,
+    tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   });
@@ -130,7 +115,7 @@ const getMissed = (document: AutoBeOpenApi.IDocument): string[] => {
   return Array.from(missed);
 };
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (
     schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
@@ -139,7 +124,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "interface",
@@ -154,14 +139,12 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
 const claude = typia.llm.application<
   IAutoBeInterfaceComplementApplication,
-  "claude",
-  { reference: true }
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
     IAutoBeInterfaceComplementApplication,
-    "chatgpt",
-    { reference: true }
+    "chatgpt"
   >(),
   claude,
   llama: claude,

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -1,4 +1,4 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeInterfaceEndpointsEvent,
   AutoBeOpenApi,
@@ -10,7 +10,6 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
 import { transformInterfaceEndpointHistories } from "./histories/transformInterfaceEndpointHistories";
 import { IAutoBeInterfaceEndpointApplication } from "./structures/IAutoBeInterfaceEndpointApplication";
 import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
@@ -20,6 +19,7 @@ export async function orchestrateInterfaceEndpoints<
 >(
   ctx: AutoBeContext<Model>,
   groups: AutoBeInterfaceGroup[],
+  authorizations: AutoBeOpenApi.IOperation[],
   content: string = `Make endpoints for the given assets`,
 ): Promise<AutoBeOpenApi.IEndpoint[]> {
   const progress: IProgress = {
@@ -27,7 +27,9 @@ export async function orchestrateInterfaceEndpoints<
     completed: 0,
   };
   const endpoints: AutoBeOpenApi.IEndpoint[] = (
-    await Promise.all(groups.map((g) => process(ctx, g, content, progress)))
+    await Promise.all(
+      groups.map((g) => process(ctx, g, content, progress, authorizations)),
+    )
   ).flat();
   return new HashSet(
     endpoints,
@@ -39,40 +41,33 @@ export async function orchestrateInterfaceEndpoints<
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   group: AutoBeInterfaceGroup,
-  content: string,
+  message: string,
   progress: IProgress,
+  authorizations: AutoBeOpenApi.IOperation[],
 ): Promise<AutoBeOpenApi.IEndpoint[]> {
   const start: Date = new Date();
   const pointer: IPointer<AutoBeOpenApi.IEndpoint[] | null> = {
     value: null,
   };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
+  const { tokenUsage } = await ctx.conversate({
+    source: "interfaceEndpoints",
+    histories: transformInterfaceEndpointHistories(
+      ctx.state(),
+      group,
+      authorizations,
+    ),
+    controller: createController({
+      model: ctx.model,
+      build: (endpoints) => {
+        pointer.value ??= endpoints;
+        pointer.value.push(...endpoints);
       },
-    },
-    histories: transformInterfaceEndpointHistories(ctx.state(), group),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (endpoints) => {
-          pointer.value ??= endpoints;
-          pointer.value.push(...endpoints);
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  await agentica.conversate(content).finally(() => {
-    const tokenUsage = agentica.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["interface"]);
+    }),
+    enforceFunctionCall: true,
+    message,
   });
   if (pointer.value === null) throw new Error("Failed to generate endpoints."); // unreachable
+
   const event: AutoBeInterfaceEndpointsEvent = {
     type: "interfaceEndpoints",
     endpoints: new HashSet(
@@ -80,6 +75,7 @@ async function process<Model extends ILlmSchema.Model>(
       OpenApiEndpointComparator.hashCode,
       OpenApiEndpointComparator.equals,
     ).toJSON(),
+    tokenUsage,
     created_at: start.toISOString(),
     step: ctx.state().analyze?.step ?? 0,
     completed: ++progress.completed,
@@ -89,7 +85,7 @@ async function process<Model extends ILlmSchema.Model>(
   return pointer.value;
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (endpoints: AutoBeOpenApi.IEndpoint[]) => void;
 }): IAgenticaController.IClass<Model> {
@@ -97,7 +93,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: "interface",
@@ -112,14 +108,12 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
 const claude = typia.llm.application<
   IAutoBeInterfaceEndpointApplication,
-  "claude",
-  { reference: true }
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
     IAutoBeInterfaceEndpointApplication,
-    "chatgpt",
-    { reference: true }
+    "chatgpt"
   >(),
   claude,
   llama: claude,

package/src/orchestrate/interface/orchestrateInterfaceGroups.ts

@@ -1,8 +1,4 @@
-import {
-  IAgenticaController,
-  MicroAgentica,
-  MicroAgenticaHistory,
-} from "@agentica/core";
+import { IAgenticaController, MicroAgenticaHistory } from "@agentica/core";
 import {
   AutoBeAssistantMessageHistory,
   AutoBeInterfaceGroupsEvent,
@@ -21,38 +17,24 @@ export async function orchestrateInterfaceGroups<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  content: string = "Design API operations for the given assets.",
+  message: string = "Design API operations for the given assets.",
 ): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceGroupsEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBeInterfaceGroupApplication.IProps | null> = {
     value: null,
   };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-    },
+  const { histories, tokenUsage } = await ctx.conversate({
+    source: "interfaceGroups",
     histories: transformInterfaceGroupHistories(ctx.state()),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: false,
+    message,
   });
-
-  const histories: MicroAgenticaHistory<Model>[] = await agentica
-    .conversate(content)
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage().aggregate;
-      ctx.usage().record(tokenUsage, ["interface"]);
-    });
   const last: MicroAgenticaHistory<Model> = histories.at(-1)!;
   if (last.type === "assistantMessage")
     return {
@@ -67,11 +49,12 @@ export async function orchestrateInterfaceGroups<
     type: "interfaceGroups",
     created_at: start.toISOString(),
     groups: pointer.value.groups,
+    tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
   } satisfies AutoBeInterfaceGroupsEvent;
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: IAutoBeInterfaceGroupApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
@@ -79,7 +62,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: "interface",