@autobe/agent 0.21.0 → 0.22.1

package/src/context/AutoBeContext.ts

@@ -30,6 +30,7 @@ export interface AutoBeContext<Model extends ILlmSchema.Model> {
   model: Model;
   vendor: IAgenticaVendor;
   locale: string;
+  retry: number;
 
   // accessors
   compilerListener: IAutoBeCompilerListener;

package/src/context/AutoBeTokenUsageComponent.ts

@@ -95,10 +95,10 @@ export class AutoBeTokenUsageComponent
         accepted_prediction: 0,
         rejected_prediction: 0,
       };
-      return;
+    } else {
+      this.input = props.input;
+      this.output = props.output;
     }
-    this.input = props.input;
-    this.output = props.output;
   }
 
   /**

package/src/factory/consentFunctionCall.ts

@@ -12,6 +12,7 @@ import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
 
+import { AutoBeConfigConstant } from "../constants/AutoBeConfigConstant";
 import { AutoBeSystemPromptConstant } from "../constants/AutoBeSystemPromptConstant";
 import { IAutoBeConfig } from "../structures/IAutoBeConfig";
 import { IAutoBeVendor } from "../structures/IAutoBeVendor";
@@ -31,6 +32,7 @@ export const consentFunctionCall = async (props: {
     vendor: props.vendor,
     config: {
       ...(props.config ?? []),
+      retry: props.config?.retry ?? AutoBeConfigConstant.DEFAULT_RETRY,
       executor: {
         describe: null,
       },

package/src/factory/createAutoBeContext.ts

@@ -27,6 +27,7 @@ import { ILlmSchema } from "@samchon/openapi";
 import typia from "typia";
 import { v7 } from "uuid";
 
+import { AutoBeConfigConstant } from "../constants/AutoBeConfigConstant";
 import { AutoBeContext } from "../context/AutoBeContext";
 import { AutoBeState } from "../context/AutoBeState";
 import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
@@ -47,152 +48,160 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
   histories: () => AutoBeHistory[];
   usage: () => AutoBeTokenUsage;
   dispatch: (event: AutoBeEvent) => Promise<void>;
-}): AutoBeContext<Model> => ({
-  model: props.model,
-  vendor: props.vendor,
-  locale: props.config.locale ?? "en-US",
-  compilerListener: props.compilerListener,
-  compiler: props.compiler,
-  files: props.files,
-  histories: props.histories,
-  state: props.state,
-  usage: props.usage,
-  dispatch: createDispatch(props),
-  assistantMessage: (message) => {
-    props.histories().push(message);
-    setTimeout(() => props.dispatch(message).catch(() => {}));
-    return message;
-  },
-  conversate: async (next, closure) => {
-    const execute = async (): Promise<AutoBeContext.IResult<Model>> => {
-      const agent: MicroAgentica<Model> = new MicroAgentica<Model>({
-        model: props.model,
-        vendor: props.vendor,
-        config: {
-          ...(props.config ?? {}),
-          executor: {
-            describe: null,
+}): AutoBeContext<Model> => {
+  const retry: number =
+    props.config?.retry ?? AutoBeConfigConstant.DEFAULT_RETRY;
+  const locale: string = props.config.locale ?? "en-US";
+  return {
+    model: props.model,
+    vendor: props.vendor,
+    retry,
+    locale,
+    compilerListener: props.compilerListener,
+    compiler: props.compiler,
+    files: props.files,
+    histories: props.histories,
+    state: props.state,
+    usage: props.usage,
+    dispatch: createDispatch(props),
+    assistantMessage: (message) => {
+      props.histories().push(message);
+      setTimeout(() => props.dispatch(message).catch(() => {}));
+      return message;
+    },
+    conversate: async (next, closure) => {
+      const execute = async (): Promise<AutoBeContext.IResult<Model>> => {
+        const agent: MicroAgentica<Model> = new MicroAgentica<Model>({
+          model: props.model,
+          vendor: props.vendor,
+          config: {
+            ...(props.config ?? {}),
+            retry: props.config?.retry ?? AutoBeConfigConstant.DEFAULT_RETRY,
+            executor: {
+              describe: null,
+            },
           },
-        },
-        histories: next.histories,
-        controllers: [next.controller],
-      });
-      agent.on("request", async (event) => {
-        if (next.enforceFunctionCall === true && event.body.tools)
-          event.body.tool_choice = "required";
-        if (event.body.parallel_tool_calls !== undefined)
-          delete event.body.parallel_tool_calls;
-        if (next.promptCacheKey)
-          event.body.prompt_cache_key = next.promptCacheKey;
-        await props.dispatch({
-          ...event,
-          type: "vendorRequest",
-          source: next.source,
+          histories: next.histories,
+          controllers: [next.controller],
         });
-      });
-      agent.on("response", (event) => {
-        void props
-          .dispatch({
-            ...event,
-            type: "vendorResponse",
-            source: next.source,
-          })
-          .catch(() => {});
-      });
-      agent.on("jsonParseError", (event) => {
-        void props
-          .dispatch({
+        agent.on("request", async (event) => {
+          if (next.enforceFunctionCall === true && event.body.tools)
+            event.body.tool_choice = "required";
+          if (event.body.parallel_tool_calls !== undefined)
+            delete event.body.parallel_tool_calls;
+          if (next.promptCacheKey)
+            event.body.prompt_cache_key = next.promptCacheKey;
+          await props.dispatch({
             ...event,
+            type: "vendorRequest",
             source: next.source,
-          })
-          .catch(() => {});
-      });
-      agent.on("validate", (event) => {
-        void props
-          .dispatch({
-            type: "jsonValidateError",
-            id: v7(),
-            source: next.source,
-            result: event.result,
-            created_at: event.created_at,
-          })
-          .catch(() => {});
-      });
-      if (closure) closure(agent);
+          });
+        });
+        agent.on("response", (event) => {
+          void props
+            .dispatch({
+              ...event,
+              type: "vendorResponse",
+              source: next.source,
+            })
+            .catch(() => {});
+        });
+        agent.on("jsonParseError", (event) => {
+          void props
+            .dispatch({
+              ...event,
+              source: next.source,
+            })
+            .catch(() => {});
+        });
+        agent.on("validate", (event) => {
+          void props
+            .dispatch({
+              type: "jsonValidateError",
+              id: v7(),
+              source: next.source,
+              result: event.result,
+              created_at: event.created_at,
+            })
+            .catch(() => {});
+        });
+        if (closure) closure(agent);
 
-      const histories: MicroAgenticaHistory<Model>[] = await agent.conversate(
-        next.message,
-      );
-      const tokenUsage: IAutoBeTokenUsageJson.IComponent = agent
-        .getTokenUsage()
-        .toJSON().aggregate;
-      props
-        .usage()
-        .record(tokenUsage, [
-          STAGES.find((stage) => next.source.startsWith(stage)) ?? "analyze",
-        ]);
+        const histories: MicroAgenticaHistory<Model>[] = await agent.conversate(
+          next.message,
+        );
+        const tokenUsage: IAutoBeTokenUsageJson.IComponent = agent
+          .getTokenUsage()
+          .toJSON().aggregate;
+        props
+          .usage()
+          .record(tokenUsage, [
+            STAGES.find((stage) => next.source.startsWith(stage)) ?? "analyze",
+          ]);
 
-      if (
-        true === next.enforceFunctionCall &&
-        false ===
-          histories.some((h) => h.type === "execute" && h.success === true)
-      ) {
-        const failure = () => {
-          throw new Error(
-            `Failed to function calling in the ${next.source} step`,
-          );
-        };
-        const last: MicroAgenticaHistory<Model> | undefined = histories.at(-1);
         if (
-          last?.type === "assistantMessage" &&
-          last.text.trim().length !== 0
+          true === next.enforceFunctionCall &&
+          false ===
+            histories.some((h) => h.type === "execute" && h.success === true)
         ) {
-          const consent: string | null = await consentFunctionCall({
-            source: next.source,
-            dispatch: (e) => {
-              props.dispatch(e).catch(() => {});
-            },
-            config: props.config,
-            vendor: props.vendor,
-            assistantMessage: last.text,
-          });
-          if (consent !== null) {
-            const newHistories: MicroAgenticaHistory<Model>[] =
-              await agent.conversate(consent);
-            const newTokenUsage: IAutoBeTokenUsageJson.IComponent = agent
-              .getTokenUsage()
-              .toJSON().aggregate;
-            props
-              .usage()
-              .record(
-                AutoBeTokenUsageComponent.minus(
-                  new AutoBeTokenUsageComponent(newTokenUsage),
-                  new AutoBeTokenUsageComponent(tokenUsage),
-                ),
-                [
-                  STAGES.find((stage) => next.source.startsWith(stage)) ??
-                    "analyze",
-                ],
-              );
-            if (
-              newHistories.some(
-                (h) => h.type === "execute" && h.success === true,
+          const failure = () => {
+            throw new Error(
+              `Failed to function calling in the ${next.source} step`,
+            );
+          };
+          const last: MicroAgenticaHistory<Model> | undefined =
+            histories.at(-1);
+          if (
+            last?.type === "assistantMessage" &&
+            last.text.trim().length !== 0
+          ) {
+            const consent: string | null = await consentFunctionCall({
+              source: next.source,
+              dispatch: (e) => {
+                props.dispatch(e).catch(() => {});
+              },
+              config: props.config,
+              vendor: props.vendor,
+              assistantMessage: last.text,
+            });
+            if (consent !== null) {
+              const newHistories: MicroAgenticaHistory<Model>[] =
+                await agent.conversate(consent);
+              const newTokenUsage: IAutoBeTokenUsageJson.IComponent = agent
+                .getTokenUsage()
+                .toJSON().aggregate;
+              props
+                .usage()
+                .record(
+                  AutoBeTokenUsageComponent.minus(
+                    new AutoBeTokenUsageComponent(newTokenUsage),
+                    new AutoBeTokenUsageComponent(tokenUsage),
+                  ),
+                  [
+                    STAGES.find((stage) => next.source.startsWith(stage)) ??
+                      "analyze",
+                  ],
+                );
+              if (
+                newHistories.some(
+                  (h) => h.type === "execute" && h.success === true,
+                )
               )
-            )
-              return {
-                histories: newHistories,
-                tokenUsage: newTokenUsage,
-              };
+                return {
+                  histories: newHistories,
+                  tokenUsage: newTokenUsage,
+                };
+            }
           }
+          failure();
         }
-        failure();
-      }
-      return { histories, tokenUsage };
-    };
-    if (next.enforceFunctionCall === true) return forceRetry(execute);
-    else return execute();
-  },
-});
+        return { histories, tokenUsage };
+      };
+      if (next.enforceFunctionCall === true) return forceRetry(execute, retry);
+      else return execute();
+    },
+  };
+};
 
 const createDispatch = (props: {
   state: () => AutoBeState;
@@ -330,7 +339,7 @@ const transformAndDispatch = <
 
 const forceRetry = async <T>(
   task: () => Promise<T>,
-  count: number = 3,
+  count: number,
 ): Promise<T> => {
   let error: unknown = undefined;
   for (let i: number = 0; i < count; ++i)

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

@@ -26,6 +26,8 @@ export interface IAutoBeAnalyzeReviewApplication {
 export namespace IAutoBeAnalyzeReviewApplication {
   export interface IProps {
     /**
+     * Step 1 (CoT: Review Phase) - Enhancement Criteria
+     * 
      * The enhancement criteria and guidelines that the agent must follow.
      *
      * This includes:
@@ -52,6 +54,8 @@ export namespace IAutoBeAnalyzeReviewApplication {
     review: string;
 
     /**
+     * Step 2 (CoT: Plan Phase) - Original Document Plan
+     * 
      * The document plan that was used to create the content.
      *
      * This helps the reviewer understand:
@@ -67,6 +71,8 @@ export namespace IAutoBeAnalyzeReviewApplication {
     plan: string;
 
     /**
+     * Step 3 (CoT: Content Phase) - Complete Document Content
+     * 
      * The actual markdown document content that incorporates review feedback.
      *
      * This field contains a COMPLETE MARKDOWN DOCUMENT that has already 

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

@@ -15,6 +15,8 @@ export interface IAutoBeAnalyzeWriteApplication {
 export namespace IAutoBeAnalyzeWriteApplication {
   export interface IProps {
     /**
+     * Step 1 (CoT: Plan Phase) - Document Planning Structure
+     * 
      * The document planning structure that outlines what needs to be written.
      *
      * This includes:
@@ -40,6 +42,8 @@ export namespace IAutoBeAnalyzeWriteApplication {
     plan: string;
 
     /**
+     * Step 2 (CoT: Write Phase) - Document Content Creation
+     * 
      * The initial content or context for the document being written.
      *
      * This may include:

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

@@ -1,5 +1,5 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeAnalyzeRole } from "@autobe/interface";
+import { AutoBeAnalyzeHistory, AutoBeAnalyzeRole } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
@@ -13,6 +13,7 @@ export const transformInterfaceAuthorizationsHistories = (
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
+  const analyze: AutoBeAnalyzeHistory = state.analyze!;
   return [
     {
       type: "systemMessage",
@@ -21,6 +22,23 @@ export const transformInterfaceAuthorizationsHistories = (
       text: AutoBeSystemPromptConstant.INTERFACE_AUTHORIZATION,
     },
     ...transformInterfaceAssetHistories(state),
+    {
+      type: "systemMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: StringUtil.trim`
+        ## 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}
+      `,
+    },
     {
       type: "assistantMessage",
       id: v7(),

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

@@ -10,10 +10,7 @@ import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHisto
 export const transformInterfaceSchemasReviewHistories = (
   state: AutoBeState,
   operations: AutoBeOpenApi.IOperation[],
-  schemaDescriptive: Record<
-    string,
-    AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
-  >,
+  schemaDescriptive: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -20,6 +20,7 @@ import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
 import { orchestrateInterfaceGroups } from "./orchestrateInterfaceGroups";
 import { orchestrateInterfaceOperations } from "./orchestrateInterfaceOperations";
 import { orchestrateInterfaceSchemas } from "./orchestrateInterfaceSchemas";
+import { orchestrateInterfaceSchemasReview } from "./orchestrateInterfaceSchemasReview";
 
 export const orchestrateInterface =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -94,10 +95,20 @@ export const orchestrateInterface =
         schemas: await orchestrateInterfaceSchemas(ctx, operations),
       },
     };
-    Object.assign(
-      document.components.schemas,
-      await orchestrateInterfaceComplement(ctx, document),
-    );
+
+    const complementedSchemas: Record<
+      string,
+      AutoBeOpenApi.IJsonSchemaDescriptive
+    > = await orchestrateInterfaceComplement(ctx, document);
+    Object.assign(document.components.schemas, complementedSchemas);
+
+    const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+      await orchestrateInterfaceSchemasReview(
+        ctx,
+        operations,
+        document.components.schemas,
+      );
+    Object.assign(document.components.schemas, schemas);
 
     // DO COMPILE
     return ctx.dispatch({

package/src/orchestrate/interface/orchestrateInterfaceAuthorizations.ts

@@ -61,7 +61,7 @@ async function process<Model extends ILlmSchema.Model>(
     histories: transformInterfaceAuthorizationsHistories(ctx.state(), role),
     controller: createController({
       model: ctx.model,
-      role: role.name,
+      role,
       build: (next) => {
         pointer.value = next;
       },
@@ -87,7 +87,7 @@ async function process<Model extends ILlmSchema.Model>(
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  role: string;
+  role: AutoBeAnalyzeRole;
   build: (next: IAutoBeInterfaceAuthorizationsApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
@@ -99,11 +99,18 @@ function createController<Model extends ILlmSchema.Model>(props: {
       typia.validate<IAutoBeInterfaceAuthorizationsApplication.IProps>(next);
     if (result.success === false) return result;
 
+    // remove login operation for guest role
+    if (props.role.kind === "guest") {
+      result.data.operations = result.data.operations.filter(
+        (op) => op.authorizationType !== "login",
+      );
+    }
+
     const errors: IValidation.IError[] = [];
     result.data.operations.forEach((op, i) => {
       // validate authorizationRole
       if (op.authorizationRole !== null) {
-        op.authorizationRole = props.role;
+        op.authorizationRole = props.role.name;
       }
 
       // validate responseBody.typeName -> must be ~.IAuthorized
@@ -148,7 +155,8 @@ function createController<Model extends ILlmSchema.Model>(props: {
         .filter((v) => v !== null),
     );
     for (const type of typia.misc.literals<AuthorizationType>())
-      if (authorizationTypes.has(type) === false)
+      if (props.role.kind === "guest" && type === "login") continue;
+      else if (authorizationTypes.has(type) === false)
         errors.push({
           path: "$input.operations[].authorizationType",
           expected: StringUtil.trim`{
@@ -160,7 +168,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
           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}" 
+          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.

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 { JsonSchemaValidator } from "./utils/JsonSchemaValidator";
+import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
 
 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[] = [];
+    JsonSchemaValidator.validate({
+      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>;