@autobe/agent 0.18.0 → 0.19.1

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.ts

@@ -1,5 +1,6 @@
 import { AutoBeAnalyzeRole, CamelPattern } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { tags } from "typia";
 
 export interface IAutoBeAnalyzeScenarioApplication {
   /**
@@ -28,7 +29,7 @@ export namespace IAutoBeAnalyzeScenarioApplication {
      * Prefix for file names and variable names. This will be used for
      * organizing documentation files.
      *
-     * MUST use camelCase naming convention.
+     * DO: Use camelCase naming convention.
      */
     prefix: string & CamelPattern;
 
@@ -64,9 +65,8 @@ export namespace IAutoBeAnalyzeScenarioApplication {
      * - Service overview and business model description
      * - User roles and permission requirements (described in natural language)
      * - Business logic and validation rules
-     * - STRICTLY PROHIBITED: Do NOT include database schemas, ERD, or API
-     *   specifications
-     * - All requirements must be written in natural language for clarity
+     * - DO NOT: Include database schemas, ERD, or API specifications
+     * - DO: Write all requirements in natural language for clarity
      *
      * Generate files based on actual requirements gathered from conversation.
      * Do not create unnecessary documentation - only generate what is needed to
@@ -80,6 +80,6 @@ export namespace IAutoBeAnalyzeScenarioApplication {
      * user does not specify a number, generate a sufficient number of documents
      * to adequately support the service.
      */
-    files: Array<AutoBeAnalyzeFile.Scenario>;
+    files: Array<AutoBeAnalyzeFile.Scenario> & tags.MinItems<1>;
   }
 }

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

@@ -59,6 +59,7 @@ export const transformInterfaceAssetHistories = (
         "4. Verify EVERY field reference against the actual schema before including in descriptions",
         "",
         "## Prisma DB Schema",
+        "",
         "```json",
         JSON.stringify(prisma.schemas),
         "```",

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

@@ -44,18 +44,8 @@ export const transformInterfaceEndpointHistories = (
           name: op.name,
           summary: op.summary,
         })),
-        null,
-        2,
       ),
       "```",
-      "",
-      "**DO NOT CREATE:**",
-      "- User creation endpoints (POST /users, POST /admins)",
-      "- Authentication endpoints (handled separately)",
-      "- Focus only on business data operations",
-      "",
-      "Create operations for DIFFERENT paths and DIFFERENT purposes only.",
-      "",
     ].join("\n"),
   },
 ];

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

@@ -35,7 +35,7 @@ export function transformInterfaceOperationsReviewHistories<
         "Review the following API operations:",
         "",
         "```json",
-        JSON.stringify(operations, null, 2),
+        JSON.stringify(operations),
         "```",
       ].join("\n"),
     },

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

@@ -21,9 +21,15 @@ export const transformInterfaceSchemasReviewHistories = (
       type: "systemMessage",
       id: v4(),
       created_at: new Date().toISOString(),
-      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_REVIEW,
+      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
     },
     ...transformInterfaceAssetHistories(state),
+    {
+      type: "systemMessage",
+      id: v4(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_REVIEW,
+    },
     {
       type: "assistantMessage",
       id: v4(),
@@ -33,7 +39,7 @@ export const transformInterfaceSchemasReviewHistories = (
         "These operations define what endpoints exist and what request/response types they use:",
         "",
         "```json",
-        JSON.stringify(operations, null, 2),
+        JSON.stringify(operations),
         "```",
         "",
         "All schema types referenced in these operations (in requestBody and responses) must exist in the schemas.",
@@ -47,7 +53,7 @@ export const transformInterfaceSchemasReviewHistories = (
         "Here are the schemas generated by the Schema Agent that need your review:",
         "",
         "```json",
-        JSON.stringify(schemaDescriptive, null, 2),
+        JSON.stringify(schemaDescriptive),
         "```",
         "",
         "Please review these schemas for:",

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -1,14 +1,19 @@
 import {
   AutoBeAssistantMessageHistory,
+  AutoBeInterfaceAuthorization,
   AutoBeInterfaceCompleteEvent,
   AutoBeInterfaceGroupsEvent,
   AutoBeInterfaceHistory,
   AutoBeOpenApi,
 } from "@autobe/interface";
+import { AutoBeEndpointComparator } from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
+import { HashMap, Pair } from "tstl";
+import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { orchestrateInterfaceAuthorizations } from "./orchestrateInterfaceAuthorizations";
 import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement";
 import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
@@ -21,8 +26,20 @@ export const orchestrateInterface =
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceHistory> => {
-    // ENDPOINTS
+    // PREDICATION
     const start: Date = new Date();
+    const predicate: string | null = predicateStateMessage(
+      ctx.state(),
+      "interface",
+    );
+    if (predicate !== null)
+      return ctx.assistantMessage({
+        type: "assistantMessage",
+        id: v4(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
     ctx.dispatch({
       type: "interfaceStart",
       created_at: start.toISOString(),
@@ -30,22 +47,43 @@ export const orchestrateInterface =
       step: ctx.state().analyze?.step ?? 0,
     });
 
-    const init: AutoBeAssistantMessageHistory | AutoBeInterfaceGroupsEvent =
+    // ENDPOINTS
+    const init: AutoBeInterfaceGroupsEvent =
       await orchestrateInterfaceGroups(ctx);
-    if (init.type === "assistantMessage") return ctx.assistantMessage(init);
-    else ctx.dispatch(init);
+    ctx.dispatch(init);
 
     // AUTHORIZATION
-    const authorizations: AutoBeOpenApi.IOperation[] =
+    const authorizations: AutoBeInterfaceAuthorization[] =
       await orchestrateInterfaceAuthorizations(ctx);
 
+    const authOperations = authorizations
+      .map((authorization) => authorization.operations)
+      .flat();
+
     // ENDPOINTS & OPERATIONS
     const endpoints: AutoBeOpenApi.IEndpoint[] =
-      await orchestrateInterfaceEndpoints(ctx, init.groups, authorizations);
-    const operations: AutoBeOpenApi.IOperation[] =
+      await orchestrateInterfaceEndpoints(ctx, init.groups, authOperations);
+    const firstOperations: AutoBeOpenApi.IOperation[] =
       await orchestrateInterfaceOperations(ctx, endpoints);
-
-    operations.push(...authorizations);
+    const operations: AutoBeOpenApi.IOperation[] = new HashMap<
+      AutoBeOpenApi.IEndpoint,
+      AutoBeOpenApi.IOperation
+    >(
+      [...authOperations, ...firstOperations].map(
+        (o) =>
+          new Pair(
+            {
+              path: o.path,
+              method: o.method,
+            },
+            o, // early inserted be kept
+          ),
+      ),
+      AutoBeEndpointComparator.hashCode,
+      AutoBeEndpointComparator.equals,
+    )
+      .toJSON()
+      .map((it) => it.second);
 
     // TYPE SCHEMAS
     const document: AutoBeOpenApi.IDocument = {
@@ -55,15 +93,16 @@ export const orchestrateInterface =
         schemas: await orchestrateInterfaceSchemas(ctx, operations),
       },
     };
-    document.components.schemas = await orchestrateInterfaceComplement(
-      ctx,
-      document,
+    Object.assign(
+      document.components.schemas,
+      await orchestrateInterfaceComplement(ctx, document),
     );
 
     // DO COMPILE
     return ctx.dispatch({
       type: "interfaceComplete",
       document,
+      authorizations,
       created_at: new Date().toISOString(),
       elapsed: new Date().getTime() - start.getTime(),
       step: ctx.state().analyze?.step ?? 0,

package/src/orchestrate/interface/orchestrateInterfaceAuthorizations.ts

@@ -1,25 +1,30 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeAnalyzeRole, AutoBeOpenApi } from "@autobe/interface";
+import {
+  AutoBeAnalyzeRole,
+  AutoBeInterfaceAuthorization,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
 import { AutoBeInterfaceAuthorizationEvent } from "@autobe/interface/src/events/AutoBeInterfaceAuthorizationEvent";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { StringUtil } from "@autobe/utils";
+import { ILlmApplication, ILlmSchema, IValidation } 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[]> {
+>(ctx: AutoBeContext<Model>): Promise<AutoBeInterfaceAuthorization[]> {
   const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: roles.length,
     completed: 0,
   };
-  const operations: AutoBeOpenApi.IOperation[][] = await Promise.all(
+  const authorizations: AutoBeInterfaceAuthorization[] = await Promise.all(
     roles.map(async (role) => {
       const event: AutoBeInterfaceAuthorizationEvent = await process(
         ctx,
@@ -27,16 +32,20 @@ export async function orchestrateInterfaceAuthorizations<
         progress,
       );
       ctx.dispatch(event);
-      return event.operations;
+      return {
+        role: role.name,
+        operations: event.operations,
+      };
     }),
   );
-  return operations.flat();
+
+  return authorizations;
 }
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   role: AutoBeAnalyzeRole,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
 ): Promise<AutoBeInterfaceAuthorizationEvent> {
   const pointer: IPointer<IAutoBeInterfaceAuthorizationsApplication.IProps | null> =
     {
@@ -47,6 +56,7 @@ async function process<Model extends ILlmSchema.Model>(
     histories: transformInterfaceAuthorizationsHistories(ctx.state(), role),
     controller: createController({
       model: ctx.model,
+      role: role.name,
       build: (next) => {
         pointer.value = next;
       },
@@ -70,13 +80,100 @@ async function process<Model extends ILlmSchema.Model>(
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  role: string;
   build: (next: IAutoBeInterfaceAuthorizationsApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps> =
+      typia.validate<IAutoBeInterfaceAuthorizationsApplication.IProps>(next);
+    if (result.success === false) return result;
+
+    const errors: IValidation.IError[] = [];
+    result.data.operations.forEach((op, i) => {
+      // validate authorizationRole
+      if (op.authorizationRole !== null) {
+        op.authorizationRole = props.role;
+      }
+
+      // validate responseBody.typeName -> must be ~.IAuthorized
+      if (op.authorizationType === null) return;
+      else if (op.responseBody === null)
+        errors.push({
+          path: `$input.operations.${i}.responseBody`,
+          expected:
+            "Response body with I{RoleName(PascalCase)}.IAuthorized type is required",
+          value: op.responseBody,
+          description: [
+            "Response body is required for authentication operations.",
+            "",
+            "The responseBody must contain description and typeName fields.",
+            "typeName must be I{Prefix(PascalCase)}{RoleName(PascalCase)}.IAuthorized",
+            "description must be a detailed description of the response body.",
+          ].join("\n"),
+        });
+      else if (!op.responseBody.typeName.endsWith(".IAuthorized"))
+        errors.push({
+          path: `$input.operations.${i}.responseBody.typeName`,
+          expected: `Type name must be I{RoleName(PascalCase)}.IAuthorized`,
+          value: op.responseBody?.typeName,
+          description: [
+            `Wrong response body type name: ${op.responseBody?.typeName}`,
+            "",
+            `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).`,
+          ].join("\n"),
+        });
+    });
+
+    // validate authorization types' existence
+    type AuthorizationType = NonNullable<
+      AutoBeOpenApi.IOperation["authorizationType"]
+    >;
+    const authorizationTypes: Set<AuthorizationType> = new Set(
+      result.data.operations
+        .map((o) => o.authorizationType)
+        .filter((v) => v !== null),
+    );
+    for (const type of typia.misc.literals<AuthorizationType>())
+      if (authorizationTypes.has(type) === false)
+        errors.push({
+          path: "$input.operations[].authorizationType",
+          expected: StringUtil.trim`{
+          ...(AutoBeOpenApi.IOperation data),
+          authorizationType: "${type}"
+        }`,
+          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}".
+
+          However, none of the operations have the AutoBeOpenApi.IOperation.authorizationType := "${type}" 
+          value, so that the "${props.role}" cannot perform the authorization ${type} activity.
+
+          Please make that operation at the next function calling. You have to do it.
+        `,
+        });
+    if (errors.length !== 0) {
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    }
+    return result;
+  };
+
   const application: ILlmApplication<Model> = collection[
-    props.model
-  ] as unknown as ILlmApplication<Model>;
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -90,17 +187,23 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeInterfaceAuthorizationsApplication,
-  "claude"
->();
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceAuthorizationsApplication,
-    "chatgpt"
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "chatgpt">(
+      {
+        validate: {
+          makeOperations: validate,
+        },
+      },
+    ),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "claude">({
+      validate: {
+        makeOperations: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceAuthorizationsApplication.IProps>;

package/src/orchestrate/interface/orchestrateInterfaceGroups.ts

@@ -1,12 +1,8 @@
-import { IAgenticaController, MicroAgenticaHistory } from "@agentica/core";
-import {
-  AutoBeAssistantMessageHistory,
-  AutoBeInterfaceGroupsEvent,
-} from "@autobe/interface";
+import { IAgenticaController } from "@agentica/core";
+import { AutoBeInterfaceGroupsEvent } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
-import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
@@ -18,12 +14,12 @@ export async function orchestrateInterfaceGroups<
 >(
   ctx: AutoBeContext<Model>,
   message: string = "Design API operations for the given assets.",
-): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceGroupsEvent> {
+): Promise<AutoBeInterfaceGroupsEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBeInterfaceGroupApplication.IProps | null> = {
     value: null,
   };
-  const { histories, tokenUsage } = await ctx.conversate({
+  const { tokenUsage } = await ctx.conversate({
     source: "interfaceGroups",
     histories: transformInterfaceGroupHistories(ctx.state()),
     controller: createController({
@@ -32,19 +28,10 @@ export async function orchestrateInterfaceGroups<
         pointer.value = next;
       },
     }),
-    enforceFunctionCall: false,
+    enforceFunctionCall: true,
     message,
   });
-  const last: MicroAgenticaHistory<Model> = histories.at(-1)!;
-  if (last.type === "assistantMessage")
-    return {
-      ...last,
-      created_at: start.toISOString(),
-      completed_at: new Date().toISOString(),
-      id: v4(),
-    } satisfies AutoBeAssistantMessageHistory;
-  else if (pointer.value === null)
-    throw new Error("Failed to generate groups."); // unreachable
+  if (pointer.value === null) throw new Error("Failed to generate groups."); // unreachable
   return {
     type: "interfaceGroups",
     created_at: start.toISOString(),

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -24,7 +24,7 @@ export async function orchestrateInterfaceOperations<
 >(
   ctx: AutoBeContext<Model>,
   endpoints: AutoBeOpenApi.IEndpoint[],
-  capacity: number = 12,
+  capacity: number = 8,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const matrix: AutoBeOpenApi.IEndpoint[][] = divideArray({
     array: endpoints,
@@ -34,13 +34,11 @@ export async function orchestrateInterfaceOperations<
     total: endpoints.length,
     completed: 0,
   };
-
   const operationsReviewProgress: IProgress = {
-    total: endpoints.length,
+    total: matrix.length,
     completed: 0,
   };
-
-  const operations: AutoBeOpenApi.IOperation[] = (
+  return (
     await Promise.all(
       matrix.map(async (it) => {
         const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
@@ -54,8 +52,6 @@ export async function orchestrateInterfaceOperations<
       }),
     )
   ).flat();
-
-  return operations;
 }
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
@@ -77,28 +73,28 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
     );
   for (let i: number = 0; i < retry; ++i) {
     if (remained.empty() === true || unique.size() >= endpoints.length) break;
-    const operations: AutoBeOpenApi.IOperation[] = await process(
-      ctx,
-      Array.from(remained),
-      operationsProgress,
-    );
-    const newbie: AutoBeOpenApi.IOperation[] =
-      await orchestrateInterfaceOperationsReview(
-        ctx,
-        operations,
-        operationsReviewProgress,
-      );
-    for (const item of newbie) {
+    const operations: AutoBeOpenApi.IOperation[] = remained.size()
+      ? await process(ctx, remained, operationsProgress)
+      : [];
+
+    for (const item of operations) {
       unique.set(item, item);
       remained.erase(item);
     }
   }
+  const newbie: AutoBeOpenApi.IOperation[] =
+    await orchestrateInterfaceOperationsReview(
+      ctx,
+      unique.toJSON().map((it) => it.second),
+      operationsReviewProgress,
+    );
+  for (const item of newbie) unique.set(item, item);
   return unique.toJSON().map((it) => it.second);
 }
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
+  endpoints: HashSet<AutoBeOpenApi.IEndpoint>,
   progress: IProgress,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
@@ -107,7 +103,10 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceOperations",
-    histories: transformInterfaceOperationHistories(ctx.state(), endpoints),
+    histories: transformInterfaceOperationHistories(
+      ctx.state(),
+      endpoints.toJSON(),
+    ),
     controller: createController({
       model: ctx.model,
       roles: ctx.state().analyze?.roles.map((it) => it.name) ?? [],
@@ -124,9 +123,9 @@ async function process<Model extends ILlmSchema.Model>(
                     .filter((it) => it !== "")
                     .join("/"),
                 authorizationRole: null,
+                authorizationType: null,
               },
             ];
-
           return op.authorizationRoles.map((role) => ({
             ...op,
             path:
@@ -135,20 +134,27 @@ async function process<Model extends ILlmSchema.Model>(
                 .filter((it) => it !== "")
                 .join("/"),
             authorizationRole: role,
+            authorizationType: null,
           }));
         });
+        pointer.value.push(...matrix.flat());
         progress.completed += matrix.flat().length;
-        progress.total += matrix
-          .filter((it) => it.length > 1)
-          .map((it) => it.length - 1)
+        progress.total += operations
+          .map((op) =>
+            endpoints.has({ path: op.path, method: op.method })
+              ? op.authorizationRoles.length === 0
+                ? 0
+                : op.authorizationRoles.length - 1
+              : op.authorizationRoles.length,
+          )
           .reduce((a, b) => a + b, 0);
-        pointer.value.push(...matrix.flat());
       },
     }),
     enforceFunctionCall: true,
     message: "Make API operations",
   });
   if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
+
   ctx.dispatch({
     type: "interfaceOperations",
     operations: pointer.value,
@@ -288,7 +294,6 @@ function createController<Model extends ILlmSchema.Model>(props: {
       }
       indexes.push(i);
     });
-
     if (errors.length !== 0)
       return {
         success: false,