@autobe/agent 0.20.0 → 0.22.0

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -3,6 +3,7 @@ import { AutoBeOpenApi } from "@autobe/interface";
 import {
   ILlmApplication,
   ILlmSchema,
+  IValidation,
   OpenApiTypeChecker,
 } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
@@ -14,22 +15,25 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { transformInterfaceComplementHistories } from "./histories/transformInterfaceComplementHistories";
 import { IAutoBeInterfaceComplementApplication } from "./structures/IAutoBeInterfaceComplementApplication";
+import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
+import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
+import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
+import { validateAuthorizationSchema } from "./utils/validateAuthorizationSchema";
 
 export function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   document: AutoBeOpenApi.IDocument,
-  life: number = 8,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  return step(ctx, document, life);
+  return step(ctx, document, 8);
 }
 
 async function step<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   document: AutoBeOpenApi.IDocument,
-  retry: number,
+  life: number,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const missed: string[] = getMissed(document);
-  if (missed.length === 0 || retry <= 0) {
+  if (missed.length === 0 || life <= 0) {
     return document.components.schemas;
   }
 
@@ -83,6 +87,7 @@ async function step<Model extends ILlmSchema.Model>(
     ...pointer.value,
     ...document.components.schemas,
   };
+  JsonSchemaNamingConvention.schemas(document.operations, newSchemas);
   return step(
     ctx,
     {
@@ -92,7 +97,7 @@ async function step<Model extends ILlmSchema.Model>(
         schemas: newSchemas,
       },
     },
-    retry - 1,
+    life - 1,
   );
 }
 
@@ -124,9 +129,39 @@ function createController<Model extends ILlmSchema.Model>(props: {
   ) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
+
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceComplementApplication.IProps> => {
+    JsonSchemaFactory.fix("schemas", next);
+
+    const result: IValidation<IAutoBeInterfaceComplementApplication.IProps> =
+      typia.validate<IAutoBeInterfaceComplementApplication.IProps>(next);
+    if (result.success === false) {
+      fulfillJsonSchemaErrorMessages(result.errors);
+      return result;
+    }
+
+    const errors: IValidation.IError[] = [];
+    validateAuthorizationSchema({
+      errors,
+      schemas: result.data.schemas,
+      path: "$input.schemas",
+    });
+    if (errors.length !== 0)
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    return result;
+  };
+
   const application: ILlmApplication<Model> = collection[
-    props.model
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "interface",
@@ -139,17 +174,21 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeInterfaceComplementApplication,
-  "claude"
->();
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceComplementApplication,
-    "chatgpt"
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceComplementApplication, "chatgpt">({
+      validate: {
+        complementComponents: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceComplementApplication, "claude">({
+      validate: {
+        complementComponents: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceComplementApplication.IProps>;

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -14,6 +14,7 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceEndpointHistories } from "./histories/transformInterfaceEndpointHistories";
+import { orchestrateInterfaceEndpointsReview } from "./orchestrateInterfaceEndpointsReview";
 import { IAutoBeInterfaceEndpointApplication } from "./structures/IAutoBeInterfaceEndpointApplication";
 import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
 
@@ -37,11 +38,14 @@ export async function orchestrateInterfaceEndpoints<
       ),
     )
   ).flat();
-  return new HashSet(
+
+  const deduplicated: AutoBeOpenApi.IEndpoint[] = new HashSet(
     endpoints,
     OpenApiEndpointComparator.hashCode,
     OpenApiEndpointComparator.equals,
   ).toJSON();
+
+  return orchestrateInterfaceEndpointsReview(ctx, deduplicated);
 }
 
 async function process<Model extends ILlmSchema.Model>(

package/src/orchestrate/interface/orchestrateInterfaceEndpointsReview.ts

@@ -0,0 +1,95 @@
+import { IAgenticaController } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { transformInterfaceEndpointsReviewHistories } from "./histories/transformInterfaceEndpointsReviewHistories";
+import { IAutoBeInterfaceEndpointsReviewApplication } from "./structures/IAutoBeInterfaceEndpointsReviewApplication";
+
+export async function orchestrateInterfaceEndpointsReview<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  endpoints: AutoBeOpenApi.IEndpoint[],
+  message: string = `Review the generated endpoints`,
+): Promise<AutoBeOpenApi.IEndpoint[]> {
+  const pointer: IPointer<IAutoBeInterfaceEndpointsReviewApplication.IProps | null> =
+    {
+      value: null,
+    };
+
+  const { tokenUsage } = await ctx.conversate({
+    source: "interfaceEndpointsReview",
+    histories: transformInterfaceEndpointsReviewHistories(
+      ctx.state(),
+      endpoints,
+    ),
+    controller: createController({
+      model: ctx.model,
+      build: (props) => {
+        pointer.value = props;
+      },
+    }),
+    enforceFunctionCall: true,
+    message,
+  });
+
+  if (pointer.value === null) {
+    return endpoints;
+  }
+
+  const response = pointer.value?.endpoints ?? [];
+
+  ctx.dispatch({
+    id: v7(),
+    type: "interfaceEndpointsReview",
+    endpoints,
+    content: response,
+    created_at: new Date().toISOString(),
+    review: pointer.value?.review,
+    step: ctx.state().analyze?.step ?? 0,
+    tokenUsage,
+  });
+
+  return response;
+}
+
+export function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (props: IAutoBeInterfaceEndpointsReviewApplication.IProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "interface",
+    application,
+    execute: {
+      reviewEndpoints: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeInterfaceEndpointsReviewApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeInterfaceEndpointsReviewApplication,
+  "claude"
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeInterfaceEndpointsReviewApplication,
+    "chatgpt"
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -34,21 +34,22 @@ export async function orchestrateInterfaceOperations<
     capacity,
   });
 
+  const progress: AutoBeProgressEventBase = {
+    total: matrix.flat().length,
+    completed: 0,
+  };
+  const reviewProgress: AutoBeProgressEventBase = {
+    total: matrix.length,
+    completed: 0,
+  };
   return (
     await executeCachedBatch(
       matrix.map((it) => async (promptCacheKey) => {
         const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
           ctx,
           it,
-          3,
-          {
-            total: matrix.length,
-            completed: 0,
-          },
-          {
-            total: matrix.length,
-            completed: 0,
-          },
+          progress,
+          reviewProgress,
           promptCacheKey,
         );
         return row;
@@ -60,7 +61,6 @@ export async function orchestrateInterfaceOperations<
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   endpoints: AutoBeOpenApi.IEndpoint[],
-  retry: number,
   operationsProgress: AutoBeProgressEventBase,
   operationsReviewProgress: AutoBeProgressEventBase,
   promptCacheKey: string,
@@ -75,7 +75,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
       OpenApiEndpointComparator.hashCode,
       OpenApiEndpointComparator.equals,
     );
-  for (let i: number = 0; i < retry; ++i) {
+  for (let i: number = 0; i < ctx.retry; ++i) {
     if (remained.empty() === true || unique.size() >= endpoints.length) break;
     const operations: AutoBeOpenApi.IOperation[] = remained.size()
       ? await process(ctx, remained, operationsProgress, promptCacheKey)

package/src/orchestrate/interface/orchestrateInterfaceOperationsReview.ts

@@ -2,6 +2,7 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeInterfaceOperationsReviewEvent,
   AutoBeOpenApi,
+  AutoBePrisma,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
@@ -21,6 +22,7 @@ export async function orchestrateInterfaceOperationsReview<
   progress: AutoBeProgressEventBase,
 ): Promise<AutoBeOpenApi.IOperation[]> {
   try {
+    const files: AutoBePrisma.IFile[] = ctx.state().prisma?.result.data.files!;
     const pointer: IPointer<IAutoBeInterfaceOperationsReviewApplication.IProps | null> =
       {
         value: null,
@@ -30,6 +32,7 @@ export async function orchestrateInterfaceOperationsReview<
       histories: transformInterfaceOperationsReviewHistories(ctx, operations),
       controller: createReviewController({
         model: ctx.model,
+        prismaSchemas: files,
         build: (next: IAutoBeInterfaceOperationsReviewApplication.IProps) => {
           pointer.value = next;
         },
@@ -39,7 +42,7 @@ export async function orchestrateInterfaceOperationsReview<
     });
     if (pointer.value === null) {
       console.error("Failed to review operations.");
-      progress.completed += operations.length;
+      ++progress.completed;
       return [];
     }
 
@@ -54,8 +57,8 @@ export async function orchestrateInterfaceOperationsReview<
       type: "interfaceOperationsReview",
       id: v7(),
       operations: content,
-      review: pointer.value.review,
-      plan: pointer.value.plan,
+      review: pointer.value.think.review,
+      plan: pointer.value.think.plan,
       content,
       tokenUsage,
       created_at: new Date().toISOString(),
@@ -73,6 +76,7 @@ export async function orchestrateInterfaceOperationsReview<
 
 function createReviewController<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  prismaSchemas: AutoBePrisma.IFile[];
   build: (reviews: IAutoBeInterfaceOperationsReviewApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   const application: ILlmApplication<Model> = collection[

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -8,7 +8,7 @@ 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";
-import typia, { tags } from "typia";
+import typia from "typia";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -16,8 +16,10 @@ import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceSchemaHistories } from "./histories/transformInterfaceSchemaHistories";
-import { orchestrateInterfaceSchemasReview } from "./orchestrateInterfaceSchemasReview";
 import { IAutoBeInterfaceSchemaApplication } from "./structures/IAutoBeInterfaceSchemaApplication";
+import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
+import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
+import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
 import { validateAuthorizationSchema } from "./utils/validateAuthorizationSchema";
 
 export async function orchestrateInterfaceSchemas<
@@ -25,13 +27,21 @@ export async function orchestrateInterfaceSchemas<
 >(
   ctx: AutoBeContext<Model>,
   operations: AutoBeOpenApi.IOperation[],
-  capacity: number = 8,
+  capacity: number = 5,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
+  // fix operation type names
+  JsonSchemaNamingConvention.operations(operations);
+
+  // gather type names
   const typeNames: Set<string> = new Set();
   for (const op of operations) {
     if (op.requestBody !== null) typeNames.add(op.requestBody.typeName);
     if (op.responseBody !== null) typeNames.add(op.responseBody.typeName);
   }
+  const presets: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+    JsonSchemaFactory.presets(typeNames);
+
+  // divide and conquer
   const matrix: string[][] = divideArray({
     array: Array.from(typeNames),
     capacity,
@@ -40,43 +50,22 @@ export async function orchestrateInterfaceSchemas<
     total: typeNames.size,
     completed: 0,
   };
-  const reviewProgress: AutoBeProgressEventBase = {
-    total: matrix.length,
-    completed: 0,
+  const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {
+    ...presets,
   };
-  const roles: string[] =
-    ctx.state().analyze?.roles.map((role) => role.name) ?? [];
-
-  const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-    roles.length > 0
-      ? {
-          IAuthorizationToken: authTokenSchema,
-        }
-      : {};
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(
-          ctx,
-          operations,
-          it,
-          3,
-          progress,
-          promptCacheKey,
-        );
-      const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await orchestrateInterfaceSchemasReview(
-          ctx,
-          operations,
-          row,
-          reviewProgress,
-        );
-      return { ...row, ...newbie };
+        await divideAndConquer(ctx, operations, it, progress, promptCacheKey);
+      return row;
     }),
   )) {
+    JsonSchemaNamingConvention.schemas(operations, x, y);
     Object.assign(x, y);
   }
-  if (x.IAuthorizationToken) x.IAuthorizationToken = authTokenSchema;
+  Object.assign(x, presets);
+  JsonSchemaNamingConvention.schemas(operations, x);
+  JsonSchemaFactory.authorize(x);
   return x;
 }
 
@@ -84,13 +73,12 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operations: AutoBeOpenApi.IOperation[],
   typeNames: string[],
-  retry: number,
   progress: AutoBeProgressEventBase,
   promptCacheKey: string,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const remained: Set<string> = new Set(typeNames);
   const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
-  for (let i: number = 0; i < retry; ++i) {
+  for (let i: number = 0; i < ctx.retry; ++i) {
     if (remained.size === 0) break;
     const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
       await process(
@@ -162,12 +150,11 @@ async function process<Model extends ILlmSchema.Model>(
   });
   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 ?? {};
+  const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = ((
+    OpenApiV3_1Emender.convertComponents({
+      schemas: pointer.value,
+    }) as AutoBeOpenApi.IComponents
+  ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
   ctx.dispatch({
     type: "interfaceSchemas",
     id: v7(),
@@ -198,9 +185,14 @@ function createController<Model extends ILlmSchema.Model>(props: {
   const validate = (
     next: unknown,
   ): IValidation<IAutoBeInterfaceSchemaApplication.IProps> => {
+    JsonSchemaFactory.fix("schemas", next);
+
     const result: IValidation<IAutoBeInterfaceSchemaApplication.IProps> =
       typia.validate<IAutoBeInterfaceSchemaApplication.IProps>(next);
-    if (result.success === false) return result;
+    if (result.success === false) {
+      fulfillJsonSchemaErrorMessages(result.errors);
+      return result;
+    }
 
     // Check all IAuthorized types
     const errors: IValidation.IError[] = [];
@@ -253,53 +245,3 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBeInterfaceSchemaApplication.IProps>;
-
-/**
- * Authorization token response structure.
- *
- * This interface defines the structure of the authorization token response
- * returned after successful user authentication. It contains both access and
- * refresh tokens along with their expiration information.
- *
- * This token structure is automatically included in API schemas when the system
- * detects authorization roles in the requirements analysis phase. It provides a
- * standard format for JWT-based authentication across the generated backend
- * applications.
- */
-interface IAuthorizationToken {
-  /**
-   * JWT access token for authenticated requests.
-   *
-   * This token should be included in the Authorization header for subsequent
-   * authenticated API requests as `Bearer {token}`.
-   */
-  access: string;
-
-  /**
-   * Refresh token for obtaining new access tokens.
-   *
-   * This token can be used to request new access tokens when the current access
-   * token expires, extending the user's session.
-   */
-  refresh: string;
-
-  /**
-   * Access token expiration timestamp.
-   *
-   * ISO 8601 date-time string indicating when the access token will expire and
-   * can no longer be used for authentication.
-   */
-  expired_at: string & tags.Format<"date-time">;
-
-  /**
-   * Refresh token expiration timestamp.
-   *
-   * ISO 8601 date-time string indicating the latest time until which the
-   * refresh token can be used to obtain new access tokens.
-   */
-  refreshable_until: string & tags.Format<"date-time">;
-}
-
-const authTokenSchema: AutoBeOpenApi.IJsonSchemaDescriptive =
-  typia.json.schema<IAuthorizationToken>().components.schemas!
-    .IAuthorizationToken as AutoBeOpenApi.IJsonSchemaDescriptive;