@autobe/agent 0.25.7 → 0.27.0

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -2,9 +2,10 @@ import {
   AutoBeAssistantMessageHistory,
   AutoBeInterfaceAuthorization,
   AutoBeInterfaceCompleteEvent,
-  AutoBeInterfaceGroupsEvent,
+  AutoBeInterfaceGroupEvent,
   AutoBeInterfaceHistory,
   AutoBeOpenApi,
+  AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeInterfacePrerequisite } from "@autobe/interface/src/histories/contents/AutoBeInterfacePrerequisite";
 import {
@@ -16,17 +17,20 @@ import { ILlmSchema } from "@samchon/openapi";
 import { HashMap, Pair } from "tstl";
 import { v7 } from "uuid";
 
+import { AutoBeConfigConstant } from "../../constants/AutoBeConfigConstant";
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplicationProps";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
+import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
 import { orchestrateInterfaceAuthorizations } from "./orchestrateInterfaceAuthorizations";
 import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement";
 import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
 import { orchestrateInterfaceGroups } from "./orchestrateInterfaceGroups";
 import { orchestrateInterfaceOperations } from "./orchestrateInterfaceOperations";
 import { orchestrateInterfacePrerequisites } from "./orchestrateInterfacePrerequisites";
+import { orchestrateInterfaceSchemaRename } from "./orchestrateInterfaceSchemaRename";
+import { orchestrateInterfaceSchemaReview } from "./orchestrateInterfaceSchemaReview";
 import { orchestrateInterfaceSchemas } from "./orchestrateInterfaceSchemas";
-import { orchestrateInterfaceSchemasReview } from "./orchestrateInterfaceSchemasReview";
 import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
 
 export const orchestrateInterface =
@@ -57,7 +61,7 @@ export const orchestrateInterface =
     });
 
     // ENDPOINTS
-    const init: AutoBeInterfaceGroupsEvent = await orchestrateInterfaceGroups(
+    const init: AutoBeInterfaceGroupEvent = await orchestrateInterfaceGroups(
       ctx,
       {
         instruction: props.instruction,
@@ -108,7 +112,7 @@ export const orchestrateInterface =
     const document: AutoBeOpenApi.IDocument = {
       operations,
       components: {
-        authorization: ctx.state().analyze?.roles ?? [],
+        authorizations: ctx.state().analyze?.actors ?? [],
         schemas: await orchestrateInterfaceSchemas(ctx, {
           instruction: props.instruction,
           operations,
@@ -116,9 +120,11 @@ export const orchestrateInterface =
       },
     };
 
+    const assign = (
+      schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+    ) => Object.assign(document.components.schemas, schemas);
     const complement = async () =>
-      Object.assign(
-        document.components.schemas,
+      assign(
         await orchestrateInterfaceComplement(ctx, {
           instruction: props.instruction,
           document,
@@ -126,16 +132,40 @@ export const orchestrateInterface =
       );
     await complement();
 
-    Object.assign(
-      document.components.schemas,
-      await orchestrateInterfaceSchemasReview(
-        ctx,
-        operations,
-        document.components.schemas,
+    const reviewProgress: AutoBeProgressEventBase = {
+      completed: 0,
+      total: Math.ceil(
+        Object.keys(document.components.schemas).length /
+          AutoBeConfigConstant.INTERFACE_CAPACITY,
       ),
-    );
+    };
+    for (const config of [
+      {
+        kind: "security" as const,
+        systemPrompt:
+          AutoBeSystemPromptConstant.INTERFACE_SCHEMA_SECURITY_REVIEW,
+      },
+      {
+        kind: "relation" as const,
+        systemPrompt:
+          AutoBeSystemPromptConstant.INTERFACE_SCHEMA_RELATION_REVIEW,
+      },
+      {
+        kind: "content" as const,
+        systemPrompt:
+          AutoBeSystemPromptConstant.INTERFACE_SCHEMA_CONTENT_REVIEW,
+      },
+    ])
+      assign(
+        await orchestrateInterfaceSchemaReview(ctx, config, {
+          instruction: props.instruction,
+          document,
+          progress: reviewProgress,
+        }),
+      );
     if (missedOpenApiSchemas(document).length !== 0) await complement();
 
+    await orchestrateInterfaceSchemaRename(ctx, document);
     JsonSchemaFactory.finalize({
       document,
       application: ctx.state().prisma!.result.data,
@@ -161,8 +191,9 @@ export const orchestrateInterface =
       document,
       missed: missedOpenApiSchemas(document),
       authorizations,
-      created_at: new Date().toISOString(),
-      elapsed: new Date().getTime() - start.getTime(),
+      aggregates: ctx.getCurrentAggregates("interface"),
       step: ctx.state().analyze?.step ?? 0,
+      elapsed: new Date().getTime() - start.getTime(),
+      created_at: new Date().toISOString(),
     } satisfies AutoBeInterfaceCompleteEvent);
   };

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;
   },
@@ -62,16 +62,16 @@ async function process<Model extends ILlmSchema.Model>(
     {
       value: null,
     };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "interfaceAuthorization",
     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;
       },
@@ -88,6 +88,7 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     operations: pointer.value.operations,
     completed: ++props.progress.completed,
+    metric,
     tokenUsage,
     created_at: new Date().toISOString(),
     step: ctx.state().analyze?.step ?? 0,
@@ -97,7 +98,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 +111,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 +119,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 +151,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 +166,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 +177,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/orchestrateInterfaceComplement.ts

@@ -50,7 +50,7 @@ async function step<Model extends ILlmSchema.Model>(
   > | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "interfaceComplement",
     histories: transformInterfaceComplementHistories({
       state: ctx.state(),
@@ -86,6 +86,7 @@ async function step<Model extends ILlmSchema.Model>(
     id: v7(),
     missed,
     schemas: pointer.value,
+    metric,
     tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeInterfaceEndpointsEvent,
+  AutoBeInterfaceEndpointEvent,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
@@ -53,7 +53,7 @@ export async function orchestrateInterfaceEndpoints<
     AutoBeOpenApiEndpointComparator.hashCode,
     AutoBeOpenApiEndpointComparator.equals,
   ).toJSON();
-  return orchestrateInterfaceEndpointsReview(ctx, deduplicated);
+  return await orchestrateInterfaceEndpointsReview(ctx, deduplicated);
 }
 
 async function process<Model extends ILlmSchema.Model>(
@@ -71,8 +71,8 @@ async function process<Model extends ILlmSchema.Model>(
   const pointer: IPointer<AutoBeOpenApi.IEndpoint[] | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
-    source: "interfaceEndpoints",
+  const { metric, tokenUsage } = await ctx.conversate({
+    source: "interfaceEndpoint",
     histories: transformInterfaceEndpointHistories({
       state: ctx.state(),
       group: props.group,
@@ -92,14 +92,15 @@ 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,
       AutoBeOpenApiEndpointComparator.hashCode,
       AutoBeOpenApiEndpointComparator.equals,
     ).toJSON(),
+    metric,
     tokenUsage,
     created_at: start.toISOString(),
     step: ctx.state().analyze?.step ?? 0,

package/src/orchestrate/interface/orchestrateInterfaceEndpointsReview.ts

@@ -22,8 +22,8 @@ export async function orchestrateInterfaceEndpointsReview<
       value: null,
     };
 
-  const { tokenUsage } = await ctx.conversate({
-    source: "interfaceEndpointsReview",
+  const { metric, tokenUsage } = await ctx.conversate({
+    source: "interfaceEndpointReview",
     histories: transformInterfaceEndpointsReviewHistories(
       ctx.state(),
       endpoints,
@@ -43,22 +43,21 @@ export async function orchestrateInterfaceEndpointsReview<
   }
 
   const response = pointer.value?.endpoints ?? [];
-
   ctx.dispatch({
     id: v7(),
-    type: "interfaceEndpointsReview",
+    type: "interfaceEndpointReview",
     endpoints,
     content: response,
     created_at: new Date().toISOString(),
     review: pointer.value?.review,
     step: ctx.state().analyze?.step ?? 0,
+    metric,
     tokenUsage,
   });
-
   return response;
 }
 
-export function createController<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (props: IAutoBeInterfaceEndpointsReviewApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {

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",
+  const { metric, tokenUsage } = await ctx.conversate({
+    source: "interfaceGroup",
     histories: transformInterfaceGroupHistories({
       state: ctx.state(),
       instruction: props.instruction,
@@ -40,13 +40,14 @@ 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,
+    metric,
     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";
@@ -119,8 +119,8 @@ async function process<Model extends ILlmSchema.Model>(
   const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
-    source: "interfaceOperations",
+  const { metric, tokenUsage } = await ctx.conversate({
+    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,21 @@ 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,
+    metric,
     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 +217,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,
@@ -28,8 +28,8 @@ export async function orchestrateInterfaceOperationsReview<
       {
         value: null,
       };
-    const { tokenUsage } = await ctx.conversate({
-      source: "interfaceOperationsReview",
+    const { metric, tokenUsage } = await ctx.conversate({
+      source: "interfaceOperationReview",
       histories: transformInterfaceOperationsReviewHistories(ctx, operations),
       controller: createReviewController({
         model: ctx.model,
@@ -54,18 +54,19 @@ export async function orchestrateInterfaceOperationsReview<
     );
 
     ctx.dispatch({
-      type: "interfaceOperationsReview",
+      type: "interfaceOperationReview",
       id: v7(),
       operations: content,
       review: pointer.value.think.review,
       plan: pointer.value.think.plan,
       content,
+      metric,
       tokenUsage,
       created_at: new Date().toISOString(),
       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

@@ -107,8 +107,8 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
   };
 
   try {
-    const { tokenUsage } = await ctx.conversate({
-      source: "interfacePrerequisites",
+    const { metric, tokenUsage } = await ctx.conversate({
+      source: "interfacePrerequisite",
       controller: createController({
         model: ctx.model,
         document: props.document,
@@ -131,9 +131,10 @@ 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(),
+      metric,
       tokenUsage,
       operations: pointer.value,
       total: props.progress.total,